source4/param/provision.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4    Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008-2009
   5    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include <Python.h>
  22 #include "includes.h"
  23 #include "auth/auth.h"
  24 #include "lib/ldb_wrap.h"
  25 #include "ldb/include/ldb.h"
  26 #include "ldb_errors.h"
  27 #include "libcli/raw/libcliraw.h"
  28 #include "librpc/ndr/libndr.h"
  29
  30 #include "param/param.h"
  31 #include "param/provision.h"
  32 #include "param/secrets.h"
  33 #include "lib/talloc/pytalloc.h"
  34 #include "librpc/rpc/pyrpc.h"
  35 #include "scripting/python/modules.h"
  36 #include "lib/ldb/pyldb.h"
  37 #include "param/pyparam.h"
  38
  39 static PyObject *provision_module(void)
  40 {
  41         PyObject *name = PyString_FromString("samba.provision");
  42         if (name == NULL)
  43                 return NULL;
  44         return PyImport_Import(name);
  45 }
  46
  47 static PyObject *schema_module(void)
  48 {
  49         PyObject *name = PyString_FromString("samba.schema");
  50         if (name == NULL)
  51                 return NULL;
  52         return PyImport_Import(name);
  53 }
  54
  55 NTSTATUS provision_bare(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx,
  56                         struct provision_settings *settings,
  57                         struct provision_result *result)
  58 {
  59         const char *configfile;
  60         PyObject *provision_mod, *provision_dict, *provision_fn, *py_result, *parameters;
  61
  62         DEBUG(0,("Provision for Become-DC test using python\n"));
  63
  64         py_load_samba_modules();
  65         Py_Initialize();
  66         py_update_path("bin"); /* FIXME: Can't assume this is always the case */
  67
  68         provision_mod = provision_module();
  69
  70         if (provision_mod == NULL) {
  71                 PyErr_Print();
  72                 DEBUG(0, ("Unable to import provision Python module.\n"));
  73                 return NT_STATUS_UNSUCCESSFUL;
  74         }
  75
  76         provision_dict = PyModule_GetDict(provision_mod);
  77
  78         if (provision_dict == NULL) {
  79                 DEBUG(0, ("Unable to get dictionary for provision module\n"));
  80                 return NT_STATUS_UNSUCCESSFUL;
  81         }
  82
  83         provision_fn = PyDict_GetItemString(provision_dict, "provision_become_dc");
  84         if (provision_fn == NULL) {
  85                 PyErr_Print();
  86                 DEBUG(0, ("Unable to get provision_become_dc function\n"));
  87                 return NT_STATUS_UNSUCCESSFUL;
  88         }
  89
  90         DEBUG(0,("New Server in Site[%s]\n",
  91                  settings->site_name));
  92
  93         DEBUG(0,("DSA Instance [%s]\n"
  94                 "\tinvocationId[%s]\n",
  95                 settings->ntds_dn_str,
  96                 settings->invocation_id == NULL?"None":GUID_string(mem_ctx, settings->invocation_id)));
  97
  98         DEBUG(0,("Pathes under targetdir[%s]\n",
  99                  settings->targetdir));
 100         parameters = PyDict_New();
 101
 102         configfile = lp_configfile(lp_ctx);
 103         if (configfile != NULL) {
 104                 PyDict_SetItemString(parameters, "smbconf",
 105                                      PyString_FromString(configfile));
 106         }
 107
 108         PyDict_SetItemString(parameters, "rootdn",
 109                                                  PyString_FromString(settings->root_dn_str));
 110         if (settings->targetdir != NULL)
 111                 PyDict_SetItemString(parameters, "targetdir",
 112                                                          PyString_FromString(settings->targetdir));
 113         PyDict_SetItemString(parameters, "setup_dir",
 114                              PyString_FromString("setup"));
 115         PyDict_SetItemString(parameters, "hostname",
 116                                                  PyString_FromString(settings->netbios_name));
 117         PyDict_SetItemString(parameters, "domain",
 118                                                  PyString_FromString(settings->domain));
 119         PyDict_SetItemString(parameters, "realm",
 120                                                  PyString_FromString(settings->realm));
 121         if (settings->root_dn_str)
 122                 PyDict_SetItemString(parameters, "rootdn",
 123                                      PyString_FromString(settings->root_dn_str));
 124
 125         if (settings->domain_dn_str)
 126                 PyDict_SetItemString(parameters, "domaindn",
 127                                      PyString_FromString(settings->domain_dn_str));
 128
 129         if (settings->schema_dn_str)
 130                 PyDict_SetItemString(parameters, "schemadn",
 131                                      PyString_FromString(settings->schema_dn_str));
 132
 133         if (settings->config_dn_str)
 134                 PyDict_SetItemString(parameters, "configdn",
 135                                      PyString_FromString(settings->config_dn_str));
 136
 137         if (settings->server_dn_str)
 138                 PyDict_SetItemString(parameters, "serverdn",
 139                                      PyString_FromString(settings->server_dn_str));
 140
 141         if (settings->site_name)
 142                 PyDict_SetItemString(parameters, "sitename",
 143                                      PyString_FromString(settings->site_name));
 144
 145         PyDict_SetItemString(parameters, "machinepass",
 146                              PyString_FromString(settings->machine_password));
 147
 148
 149         PyDict_SetItemString(parameters, "debuglevel", PyInt_FromLong(DEBUGLEVEL));
 150
 151         py_result = PyEval_CallObjectWithKeywords(provision_fn, NULL, parameters);
 152
 153         Py_DECREF(parameters);
 154
 155         if (py_result == NULL) {
 156                 PyErr_Print();
 157                 PyErr_Clear();
 158                 return NT_STATUS_UNSUCCESSFUL;
 159         }
 160
 161         result->domaindn = talloc_strdup(mem_ctx, PyString_AsString(PyObject_GetAttrString(py_result, "domaindn")));
 162
 163         /* FIXME paths */
 164         result->lp_ctx = lp_from_py_object(PyObject_GetAttrString(py_result, "lp"));
 165         result->samdb = PyLdb_AsLdbContext(PyObject_GetAttrString(py_result, "samdb"));
 166
 167         return NT_STATUS_OK;
 168 }
 169
 170 extern void initldb(void);
 171
 172 static PyObject *py_dom_sid_FromSid(struct dom_sid *sid)
 173 {
 174         PyObject *mod_security, *dom_sid_Type;
 175
 176         mod_security = PyImport_ImportModule("samba.dcerpc.security");
 177         if (mod_security == NULL)
 178                 return NULL;
 179
 180         dom_sid_Type = PyObject_GetAttrString(mod_security, "dom_sid");
 181         if (dom_sid_Type == NULL)
 182                 return NULL;
 183
 184         return py_talloc_reference((PyTypeObject *)dom_sid_Type, sid);
 185 }
 186
 187 NTSTATUS provision_store_self_join(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx,
 188                                    struct tevent_context *event_ctx,
 189                                    struct provision_store_self_join_settings *settings,
 190                                    const char **error_string)
 191 {
 192         int ret;
 193         PyObject *provision_mod, *provision_dict, *provision_fn, *py_result, *parameters, *py_sid;
 194         struct ldb_context *ldb;
 195         TALLOC_CTX *tmp_mem = talloc_new(mem_ctx);
 196         if (!tmp_mem) {
 197                 return NT_STATUS_NO_MEMORY;
 198         }
 199
 200         /* Open the secrets database */
 201         ldb = secrets_db_connect(tmp_mem, event_ctx, lp_ctx);
 202         if (!ldb) {
 203                 *error_string
 204                         = talloc_asprintf(mem_ctx,
 205                                           "Could not open secrets database");
 206                 talloc_free(tmp_mem);
 207                 return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
 208         }
 209
 210         ret = ldb_transaction_start(ldb);
 211
 212         if (ret != LDB_SUCCESS) {
 213                 *error_string
 214                         = talloc_asprintf(mem_ctx,
 215                                           "Could not start transaction on secrets database: %s", ldb_errstring(ldb));
 216                 talloc_free(tmp_mem);
 217                 return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
 218         }
 219
 220         py_load_samba_modules();
 221         Py_Initialize();
 222         py_update_path("bin"); /* FIXME: Can't assume this is always the case */
 223         initldb();
 224         provision_mod = provision_module();
 225
 226         if (provision_mod == NULL) {
 227                 PyErr_Print();
 228                 *error_string
 229                         = talloc_asprintf(mem_ctx, "Unable to import provision Python module.");
 230                 talloc_free(tmp_mem);
 231                 return NT_STATUS_UNSUCCESSFUL;
 232         }
 233
 234         provision_dict = PyModule_GetDict(provision_mod);
 235
 236         if (provision_dict == NULL) {
 237                 *error_string
 238                         = talloc_asprintf(mem_ctx, "Unable to get dictionary for provision module");
 239                 talloc_free(tmp_mem);
 240                 return NT_STATUS_UNSUCCESSFUL;
 241         }
 242
 243         provision_fn = PyDict_GetItemString(provision_dict, "secretsdb_self_join");
 244         if (provision_fn == NULL) {
 245                 PyErr_Print();
 246                 *error_string
 247                         = talloc_asprintf(mem_ctx, "Unable to get provision_become_dc function");
 248                 talloc_free(tmp_mem);
 249                 return NT_STATUS_UNSUCCESSFUL;
 250         }
 251
 252         parameters = PyDict_New();
 253
 254         PyDict_SetItemString(parameters, "secretsdb",
 255                              PyLdb_FromLdbContext(ldb));
 256         PyDict_SetItemString(parameters, "domain",
 257                              PyString_FromString(settings->domain_name));
 258         PyDict_SetItemString(parameters, "realm",
 259                              PyString_FromString(settings->realm));
 260         PyDict_SetItemString(parameters, "machinepass",
 261                              PyString_FromString(settings->machine_password));
 262         PyDict_SetItemString(parameters, "netbiosname",
 263                              PyString_FromString(settings->netbios_name));
 264
 265         py_sid = py_dom_sid_FromSid(settings->domain_sid);
 266         if (py_sid == NULL) {
 267                 Py_DECREF(parameters);
 268                 goto failure;
 269         }
 270
 271         PyDict_SetItemString(parameters, "domainsid",
 272                              py_sid);
 273
 274         PyDict_SetItemString(parameters, "secure_channel_type",
 275                        PyInt_FromLong(settings->secure_channel_type));
 276
 277         PyDict_SetItemString(parameters, "key_version_number",
 278                        PyInt_FromLong(settings->key_version_number));
 279
 280         py_result = PyEval_CallObjectWithKeywords(provision_fn, NULL, parameters);
 281
 282         Py_DECREF(parameters);
 283
 284         if (py_result == NULL) {
 285                 goto failure;
 286         }
 287
 288         ret = ldb_transaction_commit(ldb);
 289         if (ret != LDB_SUCCESS) {
 290                 *error_string
 291                         = talloc_asprintf(mem_ctx,
 292                                           "Could not commit transaction on secrets database: %s", ldb_errstring(ldb));
 293                 talloc_free(tmp_mem);
 294                 return NT_STATUS_INTERNAL_DB_ERROR;
 295         }
 296
 297         talloc_free(tmp_mem);
 298
 299         return NT_STATUS_OK;
 300
 301 failure:
 302         ldb_transaction_cancel(ldb);
 303         talloc_free(tmp_mem);
 304
 305         PyErr_Print();
 306         PyErr_Clear();
 307         return NT_STATUS_UNSUCCESSFUL;
 308 }
 309
 310
 311 struct ldb_context *provision_get_schema(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
 312 {
 313         const char *setupdir;
 314         PyObject *schema_mod, *schema_dict, *schema_fn, *py_result, *parameters;
 315
 316         DEBUG(0,("Schema for DRS tests using python\n"));
 317
 318         py_load_samba_modules();
 319         Py_Initialize();
 320         py_update_path("bin"); /* FIXME: Can't assume this is always the case */
 321
 322         schema_mod = schema_module();
 323
 324         if (schema_mod == NULL) {
 325                 PyErr_Print();
 326                 DEBUG(0, ("Unable to import schema Python module.\n"));
 327                 return NULL;
 328         }
 329
 330         schema_dict = PyModule_GetDict(schema_mod);
 331
 332         if (schema_dict == NULL) {
 333                 DEBUG(0, ("Unable to get dictionary for schema module\n"));
 334                 return NULL;
 335         }
 336
 337         schema_fn = PyDict_GetItemString(schema_dict, "ldb_with_schema");
 338         if (schema_fn == NULL) {
 339                 PyErr_Print();
 340                 DEBUG(0, ("Unable to get schema_get_ldb function\n"));
 341                 return NULL;
 342         }
 343
 344         parameters = PyDict_New();
 345
 346         setupdir = lp_setupdir(lp_ctx);
 347         PyDict_SetItemString(parameters, "setup_dir",
 348                              PyString_FromString(setupdir));
 349
 350         py_result = PyEval_CallObjectWithKeywords(schema_fn, NULL, parameters);
 351
 352         Py_DECREF(parameters);
 353
 354         if (py_result == NULL) {
 355                 PyErr_Print();
 356                 PyErr_Clear();
 357                 return NULL;
 358         }
 359
 360         return PyLdb_AsLdbContext(PyObject_GetAttrString(py_result, "ldb"));
 361 }