2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright © Jelmer Vernooij <jelmer@samba.org> 2008
6 Implementation of the WSGI interface described in PEP0333
7 (http://www.python.org/dev/peps/pep-0333)
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 #include "web_server/web_server.h"
26 #include "../lib/util/dlinklist.h"
27 #include "../lib/util/data_blob.h"
28 #include "lib/tls/tls.h"
32 struct websrv_context
*web
;
35 static PyObject
*start_response(PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
37 PyObject
*response_header
, *exc_info
= NULL
;
40 const char *kwnames
[] = {
41 "status", "response_header", "exc_info", NULL
43 web_request_Object
*py_web
= (web_request_Object
*)self
;
44 struct websrv_context
*web
= py_web
->web
;
45 struct http_header
*headers
= NULL
;
47 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "sO|O:start_response", discard_const_p(char *, kwnames
), &status
, &response_header
, &exc_info
)) {
53 if (!PyList_Check(response_header
)) {
54 PyErr_SetString(PyExc_TypeError
, "response_header should be list");
58 for (i
= 0; i
< PyList_Size(response_header
); i
++) {
59 struct http_header
*hdr
= talloc_zero(web
, struct http_header
);
60 PyObject
*item
= PyList_GetItem(response_header
, i
);
61 PyObject
*py_name
, *py_value
;
63 if (!PyTuple_Check(item
)) {
64 PyErr_SetString(PyExc_TypeError
, "Expected tuple");
68 if (PyTuple_Size(item
) != 2) {
69 PyErr_SetString(PyExc_TypeError
, "header tuple has invalid size, expected 2");
73 py_name
= PyTuple_GetItem(item
, 0);
75 if (!PyString_Check(py_name
)) {
76 PyErr_SetString(PyExc_TypeError
, "header name should be string");
80 py_value
= PyTuple_GetItem(item
, 1);
81 if (!PyString_Check(py_value
)) {
82 PyErr_SetString(PyExc_TypeError
, "header value should be string");
86 hdr
->name
= talloc_strdup(hdr
, PyString_AsString(py_name
));
87 hdr
->value
= talloc_strdup(hdr
, PyString_AsString(py_value
));
88 DLIST_ADD(headers
, hdr
);
91 websrv_output_headers(web
, status
, headers
);
96 static PyMethodDef web_request_methods
[] = {
97 { "start_response", (PyCFunction
)start_response
, METH_VARARGS
|METH_KEYWORDS
, NULL
},
102 PyTypeObject web_request_Type
= {
103 PyObject_HEAD_INIT(NULL
) 0,
104 .tp_name
= "wsgi.Request",
105 .tp_methods
= web_request_methods
,
106 .tp_basicsize
= sizeof(web_request_Object
),
107 .tp_flags
= Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
,
112 } error_Stream_Object
;
114 static PyObject
*py_error_flush(PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
116 /* Nothing to do here */
120 static PyObject
*py_error_write(PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
122 const char *kwnames
[] = { "str", NULL
};
125 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "s:write", discard_const_p(char *, kwnames
), &str
)) {
129 DEBUG(0, ("WSGI App: %s", str
));
134 static PyObject
*py_error_writelines(PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
136 const char *kwnames
[] = { "seq", NULL
};
137 PyObject
*seq
= NULL
, *item
;
139 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "O:writelines", discard_const_p(char *, kwnames
), &seq
)) {
143 while ((item
= PyIter_Next(seq
))) {
144 char *str
= PyString_AsString(item
);
146 DEBUG(0, ("WSGI App: %s", str
));
152 static PyMethodDef error_Stream_methods
[] = {
153 { "flush", (PyCFunction
)py_error_flush
, METH_VARARGS
|METH_KEYWORDS
, NULL
},
154 { "write", (PyCFunction
)py_error_write
, METH_VARARGS
|METH_KEYWORDS
, NULL
},
155 { "writelines", (PyCFunction
)py_error_writelines
, METH_VARARGS
|METH_KEYWORDS
, NULL
},
156 { NULL
, NULL
, 0, NULL
}
159 PyTypeObject error_Stream_Type
= {
160 PyObject_HEAD_INIT(NULL
) 0,
161 .tp_name
= "wsgi.ErrorStream",
162 .tp_basicsize
= sizeof(error_Stream_Object
),
163 .tp_methods
= error_Stream_methods
,
164 .tp_flags
= Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
,
169 struct websrv_context
*web
;
171 } input_Stream_Object
;
173 static PyObject
*py_input_read(PyObject
*_self
, PyObject
*args
, PyObject
*kwargs
)
175 const char *kwnames
[] = { "size", NULL
};
177 input_Stream_Object
*self
= (input_Stream_Object
*)_self
;
180 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "|i", discard_const_p(char *, kwnames
), &size
))
183 /* Don't read beyond buffer boundaries */
185 size
= self
->web
->input
.partial
.length
-self
->offset
;
187 size
= MIN(size
, self
->web
->input
.partial
.length
-self
->offset
);
189 ret
= PyString_FromStringAndSize((char *)self
->web
->input
.partial
.data
+self
->offset
, size
);
190 self
->offset
+= size
;
195 static PyObject
*py_input_readline(PyObject
*_self
)
198 PyErr_SetString(PyExc_NotImplementedError
,
199 "readline() not yet implemented");
203 static PyObject
*py_input_readlines(PyObject
*_self
, PyObject
*args
, PyObject
*kwargs
)
205 const char *kwnames
[] = { "hint", NULL
};
208 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "|i", discard_const_p(char *, kwnames
), &hint
))
212 PyErr_SetString(PyExc_NotImplementedError
,
213 "readlines() not yet implemented");
217 static PyObject
*py_input___iter__(PyObject
*_self
)
220 PyErr_SetString(PyExc_NotImplementedError
,
221 "__iter__() not yet implemented");
225 static PyMethodDef input_Stream_methods
[] = {
226 { "read", (PyCFunction
)py_input_read
, METH_VARARGS
|METH_KEYWORDS
, NULL
},
227 { "readline", (PyCFunction
)py_input_readline
, METH_NOARGS
, NULL
},
228 { "readlines", (PyCFunction
)py_input_readlines
, METH_VARARGS
|METH_KEYWORDS
, NULL
},
229 { "__iter__", (PyCFunction
)py_input___iter__
, METH_NOARGS
, NULL
},
230 { NULL
, NULL
, 0, NULL
}
233 PyTypeObject input_Stream_Type
= {
234 PyObject_HEAD_INIT(NULL
) 0,
235 .tp_name
= "wsgi.InputStream",
236 .tp_basicsize
= sizeof(input_Stream_Object
),
237 .tp_methods
= input_Stream_methods
,
238 .tp_flags
= Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
,
241 static PyObject
*Py_InputHttpStream(struct websrv_context
*web
)
243 input_Stream_Object
*ret
= PyObject_New(input_Stream_Object
, &input_Stream_Type
);
246 return (PyObject
*)ret
;
249 static PyObject
*Py_ErrorHttpStream(void)
251 error_Stream_Object
*ret
= PyObject_New(error_Stream_Object
, &error_Stream_Type
);
252 return (PyObject
*)ret
;
255 static PyObject
*create_environ(bool tls
, int content_length
, struct http_header
*headers
, const char *request_method
, const char *servername
, int serverport
, PyObject
*inputstream
, const char *request_string
)
258 PyObject
*errorstream
;
260 struct http_header
*hdr
;
268 errorstream
= Py_ErrorHttpStream();
269 if (errorstream
== NULL
) {
271 Py_DECREF(inputstream
);
275 PyDict_SetItemString(env
, "wsgi.input", inputstream
);
276 PyDict_SetItemString(env
, "wsgi.errors", errorstream
);
277 PyDict_SetItemString(env
, "wsgi.version", Py_BuildValue("(i,i)", 1, 0));
278 PyDict_SetItemString(env
, "wsgi.multithread", Py_False
);
279 PyDict_SetItemString(env
, "wsgi.multiprocess", Py_True
);
280 PyDict_SetItemString(env
, "wsgi.run_once", Py_False
);
281 PyDict_SetItemString(env
, "SERVER_PROTOCOL", PyString_FromString("HTTP/1.0"));
282 if (content_length
> 0) {
283 PyDict_SetItemString(env
, "CONTENT_LENGTH", PyLong_FromLong(content_length
));
285 PyDict_SetItemString(env
, "REQUEST_METHOD", PyString_FromString(request_method
));
287 questionmark
= strchr(request_string
, '?');
288 if (questionmark
== NULL
) {
289 PyDict_SetItemString(env
, "SCRIPT_NAME", PyString_FromString(request_string
));
291 PyDict_SetItemString(env
, "QUERY_STRING", PyString_FromString(questionmark
+1));
292 PyDict_SetItemString(env
, "SCRIPT_NAME", PyString_FromStringAndSize(request_string
, questionmark
-request_string
));
295 PyDict_SetItemString(env
, "SERVER_NAME", PyString_FromString(servername
));
296 PyDict_SetItemString(env
, "SERVER_PORT", PyInt_FromLong(serverport
));
297 for (hdr
= headers
; hdr
; hdr
= hdr
->next
) {
299 if (!strcasecmp(hdr
->name
, "Content-Type")) {
300 PyDict_SetItemString(env
, "CONTENT_TYPE", PyString_FromString(hdr
->value
));
302 asprintf(&name
, "HTTP_%s", hdr
->name
);
303 PyDict_SetItemString(env
, name
, PyString_FromString(hdr
->value
));
309 py_scheme
= PyString_FromString("https");
311 py_scheme
= PyString_FromString("http");
313 PyDict_SetItemString(env
, "wsgi.url_scheme", py_scheme
);
318 static void wsgi_process_http_input(struct web_server_data
*wdata
,
319 struct websrv_context
*web
)
321 PyObject
*py_environ
, *result
, *item
, *iter
;
322 PyObject
*request_handler
= (PyObject
*)wdata
->private_data
;
323 struct socket_address
*socket_address
;
325 web_request_Object
*py_web
= PyObject_New(web_request_Object
, &web_request_Type
);
328 socket_address
= socket_get_my_addr(web
->conn
->socket
, web
);
329 py_environ
= create_environ(tls_enabled(web
->conn
->socket
),
330 web
->input
.content_length
,
332 web
->input
.post_request
?"POST":"GET",
333 socket_address
->addr
,
334 socket_address
->port
,
335 Py_InputHttpStream(web
),
338 if (py_environ
== NULL
) {
339 DEBUG(0, ("Unable to create WSGI environment object\n"));
343 result
= PyObject_CallMethod(request_handler
, discard_const_p(char, "__call__"), discard_const_p(char, "OO"),
344 py_environ
, PyObject_GetAttrString((PyObject
*)py_web
, "start_response"));
346 if (result
== NULL
) {
347 DEBUG(0, ("error while running WSGI code\n"));
351 iter
= PyObject_GetIter(result
);
354 /* Now, iter over all the data returned */
356 while ((item
= PyIter_Next(iter
))) {
357 websrv_output(web
, PyString_AsString(item
), PyString_Size(item
));
364 bool wsgi_initialize(struct web_server_data
*wdata
)
370 if (PyType_Ready(&web_request_Type
) < 0)
373 if (PyType_Ready(&input_Stream_Type
) < 0)
376 if (PyType_Ready(&error_Stream_Type
) < 0)
379 wdata
->http_process_input
= wsgi_process_http_input
;
380 py_swat
= PyImport_Import(PyString_FromString("swat"));
381 if (py_swat
== NULL
) {
382 DEBUG(0, ("Unable to find SWAT\n"));
385 wdata
->private_data
= py_swat
;