import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / source / python / py_common.c
1 /* 
2    Python wrappers for DCERPC/SMB client routines.
3
4    Copyright (C) Tim Potter, 2002
5    
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include "python/py_common.h"
22
23 /* Return a tuple of (error code, error string) from a WERROR */
24
25 PyObject *py_werror_tuple(WERROR werror)
26 {
27         return Py_BuildValue("[is]", W_ERROR_V(werror), 
28                              dos_errstr(werror));
29 }
30
31 /* Return a tuple of (error code, error string) from a WERROR */
32
33 PyObject *py_ntstatus_tuple(NTSTATUS ntstatus)
34 {
35         return Py_BuildValue("[is]", NT_STATUS_V(ntstatus), 
36                              nt_errstr(ntstatus));
37 }
38
39 /* Initialise samba client routines */
40
41 static BOOL initialised;
42
43 void py_samba_init(void)
44 {
45         if (initialised)
46                 return;
47
48         /* Load configuration file */
49
50         if (!lp_load(dyn_CONFIGFILE, True, False, False))
51                 fprintf(stderr, "Can't load %s\n", dyn_CONFIGFILE);
52
53         /* Misc other stuff */
54
55         load_interfaces();
56         init_names();
57
58         initialised = True;
59 }
60
61 /* Debuglevel routines */
62
63 PyObject *get_debuglevel(PyObject *self, PyObject *args)
64 {
65         PyObject *debuglevel;
66
67         if (!PyArg_ParseTuple(args, ""))
68                 return NULL;
69
70         debuglevel = PyInt_FromLong(DEBUGLEVEL);
71
72         return debuglevel;
73 }
74
75 PyObject *set_debuglevel(PyObject *self, PyObject *args)
76 {
77         int debuglevel;
78
79         if (!PyArg_ParseTuple(args, "i", &debuglevel))
80                 return NULL;
81
82         DEBUGLEVEL = debuglevel;
83
84         Py_INCREF(Py_None);
85         return Py_None;
86 }
87
88 /* Initialise logging */
89
90 PyObject *py_setup_logging(PyObject *self, PyObject *args, PyObject *kw)
91 {
92         BOOL interactive = False;
93         char *logfilename = NULL;
94         static char *kwlist[] = {"interactive", "logfilename", NULL};
95
96         if (!PyArg_ParseTupleAndKeywords(
97                     args, kw, "|is", kwlist, &interactive, &logfilename))
98                 return NULL;
99         
100         if (interactive && logfilename) {
101                 PyErr_SetString(PyExc_RuntimeError,
102                                 "can't be interactive and set log file name");
103                 return NULL;
104         }
105
106         if (interactive)
107                 setup_logging("spoolss", True);
108
109         if (logfilename) {
110                 lp_set_logfile(logfilename);
111                 setup_logging(logfilename, False);
112                 reopen_logs();
113         }
114
115         Py_INCREF(Py_None);
116         return Py_None;
117 }
118
119 /* Parse credentials from a python dictionary.  The dictionary can
120    only have the keys "username", "domain" and "password".  Return
121    True for valid credentials in which case the username, domain and
122    password are set to pointers to their values from the dicationary.
123    If returns False, the errstr is set to point at some mallocated
124    memory describing the error. */
125
126 BOOL py_parse_creds(PyObject *creds, char **username, char **domain, 
127                     char **password, char **errstr)
128 {
129         /* Initialise anonymous credentials */
130
131         *username = "";
132         *domain = "";
133         *password = "";
134
135         if (creds && PyDict_Size(creds) > 0) {
136                 PyObject *username_obj, *password_obj, *domain_obj;
137                 PyObject *key, *value;
138                 int i;
139
140                 /* Check for presence of required fields */
141
142                 username_obj = PyDict_GetItemString(creds, "username");
143                 domain_obj = PyDict_GetItemString(creds, "domain");
144                 password_obj = PyDict_GetItemString(creds, "password");
145
146                 if (!username_obj) {
147                         *errstr = strdup("no username field in credential");
148                         return False;
149                 }
150
151                 if (!domain_obj) {
152                         *errstr = strdup("no domain field in credential");
153                         return False;
154                 }
155
156                 if (!password_obj) {
157                         *errstr = strdup("no password field in credential");
158                         return False;
159                 }
160
161                 /* Check type of required fields */
162
163                 if (!PyString_Check(username_obj)) {
164                         *errstr = strdup("username field is not string type");
165                         return False;
166                 }
167
168                 if (!PyString_Check(domain_obj)) {
169                         *errstr = strdup("domain field is not string type");
170                         return False;
171                 }
172
173                 if (!PyString_Check(password_obj)) {
174                         *errstr = strdup("password field is not string type");
175                         return False;
176                 }
177
178                 /* Look for any extra fields */
179
180                 i = 0;
181
182                 while (PyDict_Next(creds, &i, &key, &value)) {
183                         if (strcmp(PyString_AsString(key), "domain") != 0 &&
184                             strcmp(PyString_AsString(key), "username") != 0 &&
185                             strcmp(PyString_AsString(key), "password") != 0) {
186                                 asprintf(errstr,
187                                          "creds contain extra field '%s'",
188                                          PyString_AsString(key));
189                                 return False;
190                         }
191                 }
192
193                 /* Assign values */
194
195                 *username = PyString_AsString(username_obj);
196                 *domain = PyString_AsString(domain_obj);
197                 *password = PyString_AsString(password_obj);
198         }
199
200         *errstr = NULL;
201
202         return True;
203 }
204
205 /* Return a cli_state to a RPC pipe on the given server.  Use the
206    credentials passed if not NULL.  If an error occurs errstr is set to a
207    string describing the error and NULL is returned.  If set, errstr must
208    be freed by calling free(). */
209
210 struct cli_state *open_pipe_creds(char *server, PyObject *creds, 
211                                   int pipe_idx, char **errstr)
212 {
213         char *username, *password, *domain;
214         struct cli_state *cli;
215         NTSTATUS result;
216         
217         /* Extract credentials from the python dictionary */
218
219         if (!py_parse_creds(creds, &username, &domain, &password, errstr))
220                 return NULL;
221
222         /* Now try to connect */
223
224         result = cli_full_connection(
225                 &cli, NULL, server, NULL, 0, "IPC$", "IPC",
226                 username, domain, password, 0, Undefined, NULL);
227         
228         if (!NT_STATUS_IS_OK(result)) {
229                 *errstr = strdup("error connecting to IPC$ pipe");
230                 return NULL;
231         }
232
233         if (!cli_nt_session_open(cli, pipe_idx)) {
234                 cli_shutdown(cli);
235                 asprintf(errstr, "error opening pipe index %d", pipe_idx);
236                 return NULL;
237         }
238
239         *errstr = NULL;
240
241         return cli;
242 }
243
244 /* Return true if a dictionary contains a "level" key with an integer
245    value.  Set the value if so. */
246
247 BOOL get_level_value(PyObject *dict, uint32 *level)
248 {
249         PyObject *obj;
250
251         if (!(obj = PyDict_GetItemString(dict, "level")) ||
252             !PyInt_Check(obj))
253                 return False;
254
255         if (level)
256                 *level = PyInt_AsLong(obj);
257
258         return True;
259 }