static UniqueResponse
unique_message_cb (UniqueApp *app,
UniqueCommand command,
UniqueMessageData *message,
guint time_, gpointer user_data)
{
GtkWindow *window = GTK_WINDOW (user_data);
char **uris;
switch (command) {
case UNIQUE_ACTIVATE:
gtk_window_set_screen (window, unique_message_data_get_screen (message));
gtk_window_present_with_time (window, time_);
break;
case COMMAND_CALLBACK:
gtk_window_set_screen (window, unique_message_data_get_screen (message));
gtk_window_present_with_time (window, time_);
uris = unique_message_data_get_uris (message);
if (uris)
handle_uri (BISHO_WINDOW (window), uris[0]);
g_strfreev (uris);
break;
default:
break;
}
return UNIQUE_RESPONSE_OK;
}
static void test_handler_run_failed(void)
{
if (g_test_subprocess()) {
handler_add("http", "unknown-program %s");
handle_uri(TEST_URI);
return;
}
g_test_trap_subprocess(NULL, 0, 0);
g_test_trap_assert_failed();
g_test_trap_assert_stderr("*Can't run *unknown-program*");
}
static void test_handler_run_success(void)
{
if (g_test_subprocess()) {
handler_add("http", "echo -n 'handled uri %s'");
handle_uri(TEST_URI);
return;
}
g_test_trap_subprocess(NULL, 0, 0);
g_test_trap_assert_passed();
g_test_trap_assert_stdout("handled uri " TEST_URI);
}
static void *ast_httpd_helper_thread(void *data)
{
char buf[4096];
char cookie[4096];
char timebuf[256];
struct ast_http_server_instance *ser = data;
struct ast_variable *vars = NULL;
char *uri, *c, *title=NULL;
int status = 200, contentlength = 0;
time_t t;
unsigned int static_content = 0;
if (fgets(buf, sizeof(buf), ser->f)) {
/* Skip method */
uri = buf;
while(*uri && (*uri > 32))
uri++;
if (*uri) {
*uri = '\0';
uri++;
}
/* Skip white space */
while (*uri && (*uri < 33))
uri++;
if (*uri) {
c = uri;
while (*c && (*c > 32))
c++;
if (*c) {
*c = '\0';
}
}
while (fgets(cookie, sizeof(cookie), ser->f)) {
/* Trim trailing characters */
while(!ast_strlen_zero(cookie) && (cookie[strlen(cookie) - 1] < 33)) {
cookie[strlen(cookie) - 1] = '\0';
}
if (ast_strlen_zero(cookie))
break;
if (!strncasecmp(cookie, "Cookie: ", 8)) {
vars = parse_cookies(cookie);
}
}
if (*uri) {
if (!strcasecmp(buf, "get"))
c = handle_uri(&ser->requestor, uri, &status, &title, &contentlength, &vars, &static_content);
else
c = ast_http_error(501, "Not Implemented", NULL, "Attempt to use unimplemented / unsupported method");\
} else
c = ast_http_error(400, "Bad Request", NULL, "Invalid Request");
/* If they aren't mopped up already, clean up the cookies */
if (vars)
ast_variables_destroy(vars);
if (!c)
c = ast_http_error(500, "Internal Error", NULL, "Internal Server Error");
if (c) {
time(&t);
strftime(timebuf, sizeof(timebuf), "%a, %d %b %Y %H:%M:%S GMT", gmtime(&t));
ast_cli(ser->fd, "HTTP/1.1 %d %s\r\n", status, title ? title : "OK");
ast_cli(ser->fd, "Server: Asterisk/%s\r\n", ASTERISK_VERSION);
ast_cli(ser->fd, "Date: %s\r\n", timebuf);
ast_cli(ser->fd, "Connection: close\r\n");
if (!static_content)
ast_cli(ser->fd, "Cache-Control: no-cache, no-store\r\n");
/* We set the no-cache headers only for dynamic content.
* If you want to make sure the static file you requested is not from cache,
* append a random variable to your GET request. Ex: 'something.html?r=109987734'
*/
if (contentlength) {
char *tmp;
tmp = strstr(c, "\r\n\r\n");
if (tmp) {
ast_cli(ser->fd, "Content-length: %d\r\n", contentlength);
if (write(ser->fd, c, (tmp + 4 - c)) < 0) {
ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
}
if (write(ser->fd, tmp + 4, contentlength) < 0) {
ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
}
}
} else
ast_cli(ser->fd, "%s", c);
free(c);
}
if (title)
free(title);
}
fclose(ser->f);
free(ser);
ast_atomic_fetchadd_int(&session_count, -1);
return NULL;
}
/*
This is the main python handler that will transform and treat the client html request.
return 1 if we have found a python object to treat the requested uri
return 0 if not (page not found)
return -1 in case of problem
return -2 in case the request command is not implemented
*/
int python_handler(struct client *cli)
{
PyObject *pydict, *pydummy;
int ret;
if (debug)
printf("host=%s,port=%i:python_handler:HEADER:\n%s**\n", cli->remote_addr, cli->remote_port, cli->input_header);
// 1)initialise environ
PyObject *pyenviron_class=PyObject_GetAttrString(py_base_module, "Environ");
if (!pyenviron_class)
{
printf("load Environ failed from base module");
exit(1);
}
PyObject *pyenviron=PyObject_CallObject(pyenviron_class, NULL);
if (!pyenviron)
{
printf("Failed to create an instance of Environ");
exit(1);
}
Py_DECREF(pyenviron_class);
// 2)transform headers into a dictionary and send it to environ.update_headers
pydict=header_to_dict(cli);
if (pydict==Py_None)
{
Py_DECREF(pyenviron);
return -500;
}
update_environ(pyenviron, pydict, "update_headers");
Py_DECREF(pydict);
// 2bis) we check if the request method is supported
PyObject *pysupportedhttpcmd = PyObject_GetAttrString(py_base_module, "supported_HTTP_command");
if (cli->cmd==NULL) pydummy=Py_None;
else pydummy = PyString_FromString(cli->cmd);
if (PySequence_Contains(pysupportedhttpcmd,pydummy)!=1)
{
//return not implemented
Py_DECREF(pysupportedhttpcmd);
Py_DECREF(pydummy);
Py_DECREF(pyenviron);
return -501;
}
Py_DECREF(pydummy);
// 2ter) we treat directly the OPTIONS command
if (strcmp(cli->cmd,"OPTIONS")==0)
{
pydummy=PyString_FromFormat("HTTP/1.0 200 OK\r\nServer: %s\r\nAllow: ", VERSION) ;
PyObject *pyitem;
int index, max;
max = PyList_Size(pysupportedhttpcmd);
for (index=0; index<max; index++)
{
pyitem=PyList_GetItem(pysupportedhttpcmd, index); // no need to decref pyitem
PyString_Concat(&pydummy, PyObject_Str(pyitem));
if (index<max-1)
PyString_Concat(&pydummy, PyString_FromString(", "));
}
PyString_Concat(&pydummy, PyString_FromString("\r\nContent-Length: 0\r\n\r\n"));
cli->response_header = PyString_AsString(pydummy);
cli->response_header_length=(int)PyString_Size(pydummy);
cli->response_content=PyList_New(0);
Py_DECREF(pyenviron);
return 1;
}
Py_DECREF(pysupportedhttpcmd);
// 3)find if the uri is registered
if (handle_uri(cli)!=1)
{
if (py_generic_cb==NULL)
{
//printf("uri not found\n");
Py_DECREF(pyenviron);
return 0;
}
else
{
cli->wsgi_cb=py_generic_cb;
Py_INCREF(cli->wsgi_cb);
cli->uri_path=(char *)calloc(1, sizeof(char));
strcpy(cli->uri_path,"");
}
}
// 4) build path_info, ...
pydict=py_build_method_variables(cli);
update_environ(pyenviron, pydict, "update_uri");
Py_DECREF(pydict);
// 5) in case of POST, put it into the wsgi.input
if (strcmp(cli->cmd,"POST")==0)
{
ret=manage_header_body(cli, pyenviron);
if (ret < 0) {
return ret;
}
}
// 6) add some request info
pydict=py_get_request_info(cli);
update_environ(pyenviron, pydict, "update_from_request");
Py_DECREF(pydict);
// 7) build response object
PyObject *pystart_response_class=PyObject_GetAttrString(py_base_module, "Start_response");
PyObject *pystart_response=PyInstance_New(pystart_response_class, NULL, NULL);
Py_DECREF(pystart_response_class);
if (PyErr_Occurred())
{
PyErr_Print();
return -500;
}
// 7b) add the current date to the response object
PyObject *py_response_header=PyObject_GetAttrString(pystart_response,"response_headers");
char *sftime;
sftime=cur_time_rfc1123();
pydummy = PyString_FromString(sftime);
PyDict_SetItemString(py_response_header, "Date", pydummy);
Py_DECREF(pydummy);
Py_DECREF(py_response_header);
free(sftime);
pydummy = PyString_FromString(VERSION);
PyDict_SetItemString(py_response_header, "Server", pydummy);
Py_DECREF(pydummy);
// 8) execute python callbacks with his parameters
PyObject *pyarglist = Py_BuildValue("(OO)", pyenviron, pystart_response );
cli->response_content = PyEval_CallObject(cli->wsgi_cb,pyarglist);
if (cli->response_content!=NULL)
{
if ((PyFile_Check(cli->response_content)==0) && (PyIter_Check(cli->response_content)==1)) {
//This is an Iterator object. We have to execute it first
cli->response_content_obj = cli->response_content;
cli->response_content = PyIter_Next(cli->response_content_obj);
}
}
Py_DECREF(pyarglist);
Py_XDECREF(cli->wsgi_cb);
if (cli->response_content!=NULL)
{
PyObject *pydummy = PyObject_Str(pystart_response);
cli->response_header = PyString_AsString(pydummy);
cli->response_header_length = (int)PyString_Size(pydummy);
Py_DECREF(pydummy);
}
else
//python call return is NULL
{
printf("Python error!!!\n");
char buff[200];
sprintf(buff, "HTTP/1.0 500 Not found\r\nContent-Type: text/html\r\nServer: %s* \r\n\r\n", VERSION);
cli->response_header = buff;
if (cli->response_header == NULL)
{
printf("ERROR!!!! Memory allocation error in the Python error handling procedure\n");
cli->response_header_length=0;
goto leave_python_handler;
}
cli->response_header_length=strlen(cli->response_header);
if (PyErr_Occurred())
{
//get_traceback();py_b
PyObject *pyerrormsg_method=PyObject_GetAttrString(py_base_module,"redirectStdErr");
PyObject *pyerrormsg=PyObject_CallFunction(pyerrormsg_method, NULL);
Py_DECREF(pyerrormsg_method);
Py_DECREF(pyerrormsg);
PyErr_Print();
PyObject *pysys=PyObject_GetAttrString(py_base_module,"sys");
PyObject *pystderr=PyObject_GetAttrString(pysys,"stderr");
Py_DECREF(pysys);
PyObject *pygetvalue=PyObject_GetAttrString(pystderr, "getvalue");
Py_DECREF(pystderr);
PyObject *pyres=PyObject_CallFunction(pygetvalue, NULL);
Py_DECREF(pygetvalue);
printf("%s\n", PyString_AsString(pyres));
//test if we must send it to the page
PyObject *pysendtraceback = PyObject_GetAttrString(py_config_module,"send_traceback_to_browser");
cli->response_content=PyList_New(0);
if (pysendtraceback==Py_True) {
pydummy = PyString_FromString("<h1>Error</h1><pre>");
PyList_Append(cli->response_content, pydummy );
Py_DECREF(pydummy);
PyList_Append(cli->response_content, pyres);
pydummy = PyString_FromString("</pre>");
PyList_Append(cli->response_content, pydummy);
Py_DECREF(pydummy);
} else {
PyObject *pyshortmsg = PyObject_GetAttrString(py_config_module,"send_traceback_short");
PyList_Append(cli->response_content, pyshortmsg);
Py_DECREF(pyshortmsg);
}
Py_DECREF(pyres);
Py_DECREF(pysendtraceback);
}
else
{
cli->response_content=PyList_New(0);
pydummy = PyString_FromString("Page not found.");
PyList_Append(cli->response_content, pydummy );
Py_DECREF(pydummy);
}
}
leave_python_handler:
Py_XDECREF(pystart_response);
Py_XDECREF(pyenviron);
return 1;
}
static void *ast_httpd_helper_thread(void *data)
{
char buf[4096];
char cookie[4096];
char timebuf[256];
struct ast_http_server_instance *ser = data;
struct ast_variable *var, *prev=NULL, *vars=NULL;
char *uri, *c, *title=NULL;
char *vname, *vval;
int status = 200, contentlength = 0;
time_t t;
if (fgets(buf, sizeof(buf), ser->f)) {
/* Skip method */
uri = buf;
while(*uri && (*uri > 32))
uri++;
if (*uri) {
*uri = '\0';
uri++;
}
/* Skip white space */
while (*uri && (*uri < 33))
uri++;
if (*uri) {
c = uri;
while (*c && (*c > 32))
c++;
if (*c) {
*c = '\0';
}
}
while (fgets(cookie, sizeof(cookie), ser->f)) {
/* Trim trailing characters */
while(!ast_strlen_zero(cookie) && (cookie[strlen(cookie) - 1] < 33)) {
cookie[strlen(cookie) - 1] = '\0';
}
if (ast_strlen_zero(cookie))
break;
if (!strncasecmp(cookie, "Cookie: ", 8)) {
vname = cookie + 8;
vval = strchr(vname, '=');
if (vval) {
/* Ditch the = and the quotes */
*vval = '\0';
vval++;
if (*vval)
vval++;
if (strlen(vval))
vval[strlen(vval) - 1] = '\0';
var = ast_variable_new(vname, vval);
if (var) {
if (prev)
prev->next = var;
else
vars = var;
prev = var;
}
}
}
}
if (*uri) {
if (!strcasecmp(buf, "get"))
c = handle_uri(&ser->requestor, uri, &status, &title, &contentlength, &vars);
else
c = ast_http_error(501, "Not Implemented", NULL, "Attempt to use unimplemented / unsupported method");\
} else
c = ast_http_error(400, "Bad Request", NULL, "Invalid Request");
/* If they aren't mopped up already, clean up the cookies */
if (vars)
ast_variables_destroy(vars);
if (!c)
c = ast_http_error(500, "Internal Error", NULL, "Internal Server Error");
if (c) {
time(&t);
strftime(timebuf, sizeof(timebuf), "%a, %d %b %Y %H:%M:%S GMT", gmtime(&t));
ast_cli(ser->fd, "HTTP/1.1 %d %s\r\n", status, title ? title : "OK");
ast_cli(ser->fd, "Server: Asterisk\r\n");
ast_cli(ser->fd, "Date: %s\r\n", timebuf);
ast_cli(ser->fd, "Connection: close\r\n");
if (contentlength) {
char *tmp;
tmp = strstr(c, "\r\n\r\n");
if (tmp) {
ast_cli(ser->fd, "Content-length: %d\r\n", contentlength);
write(ser->fd, c, (tmp + 4 - c));
write(ser->fd, tmp + 4, contentlength);
}
} else
ast_cli(ser->fd, "%s", c);
free(c);
}
if (title)
free(title);
}
fclose(ser->f);
free(ser);
return NULL;
}
