2005-05-26 05:06:32 +04:00
/*
Unix SMB / CIFS implementation .
web server startup
Copyright ( C ) Andrew Tridgell 2005
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 2 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 , write to the Free Software
Foundation , Inc . , 675 Mass Ave , Cambridge , MA 0213 9 , USA .
*/
# include "includes.h"
# include "smbd/service_task.h"
# include "smbd/service_stream.h"
2006-03-07 17:13:38 +03:00
# include "smbd/service.h"
2005-05-26 05:06:32 +04:00
# include "web_server/web_server.h"
# include "lib/events/events.h"
# include "system/filesys.h"
2006-03-07 14:07:23 +03:00
# include "system/network.h"
2006-08-17 17:37:04 +04:00
# include "lib/socket/netif.h"
2005-06-19 08:21:45 +04:00
# include "lib/tls/tls.h"
2005-05-26 05:06:32 +04:00
/* don't allow connections to hang around forever */
# define HTTP_TIMEOUT 30
/*
destroy a web connection
*/
2006-05-24 11:35:06 +04:00
static int websrv_destructor ( struct websrv_context * web )
2005-05-26 05:06:32 +04:00
{
if ( web - > output . fd ! = - 1 ) {
close ( web - > output . fd ) ;
}
return 0 ;
}
/*
called when a connection times out . This prevents a stuck connection
from hanging around forever
*/
static void websrv_timeout ( struct event_context * event_context ,
struct timed_event * te ,
struct timeval t , void * private )
{
struct websrv_context * web = talloc_get_type ( private , struct websrv_context ) ;
2005-08-20 08:38:35 +04:00
struct stream_connection * conn = web - > conn ;
web - > conn = NULL ;
/* TODO: send a message to any running esp context on this connection
to stop running */
stream_terminate_connection ( conn , " websrv_timeout: timed out " ) ;
2005-05-26 05:06:32 +04:00
}
/*
called when a web connection becomes readable
*/
static void websrv_recv ( struct stream_connection * conn , uint16_t flags )
{
struct websrv_context * web = talloc_get_type ( conn - > private ,
struct websrv_context ) ;
NTSTATUS status ;
uint8_t buf [ 1024 ] ;
size_t nread ;
uint8_t * p ;
DATA_BLOB b ;
/* not the most efficient http parser ever, but good enough for us */
2006-05-03 00:15:47 +04:00
status = socket_recv ( conn - > socket , buf , sizeof ( buf ) , & nread ) ;
2005-05-26 05:06:32 +04:00
if ( NT_STATUS_IS_ERR ( status ) ) goto failed ;
if ( ! NT_STATUS_IS_OK ( status ) ) return ;
status = data_blob_append ( web , & web - > input . partial , buf , nread ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) goto failed ;
/* parse any lines that are available */
b = web - > input . partial ;
while ( ! web - > input . end_of_headers & &
( p = memchr ( b . data , ' \n ' , b . length ) ) ) {
2005-10-12 10:10:23 +04:00
const char * line = ( const char * ) b . data ;
2005-05-26 05:06:32 +04:00
* p = 0 ;
if ( p ! = b . data & & p [ - 1 ] = = ' \r ' ) {
p [ - 1 ] = 0 ;
}
status = http_parse_header ( web , line ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) return ;
b . length - = ( p - b . data ) + 1 ;
b . data = p + 1 ;
}
/* keep any remaining bytes in web->input.partial */
if ( b . length = = 0 ) {
b . data = NULL ;
}
b = data_blob_talloc ( web , b . data , b . length ) ;
data_blob_free ( & web - > input . partial ) ;
web - > input . partial = b ;
/* we finish when we have both the full headers (terminated by
a blank line ) and any post data , as indicated by the
content_length */
if ( web - > input . end_of_headers & &
2005-08-05 19:34:31 +04:00
web - > input . partial . length > = web - > input . content_length ) {
if ( web - > input . partial . length > web - > input . content_length ) {
web - > input . partial . data [ web - > input . content_length ] = 0 ;
}
2005-05-26 05:06:32 +04:00
EVENT_FD_NOT_READABLE ( web - > conn - > event . fde ) ;
2005-08-20 08:38:35 +04:00
/* the reference/unlink code here is quite subtle. It
is needed because the rendering of the web - pages , and
in particular the esp / ejs backend , is semi - async . So
we could well end up in the connection timeout code
while inside http_process_input ( ) , but we must not
destroy the stack variables being used by that
rendering process when we handle the timeout . */
talloc_reference ( web - > task , web ) ;
2005-05-26 05:06:32 +04:00
http_process_input ( web ) ;
2005-08-20 08:38:35 +04:00
talloc_unlink ( web - > task , web ) ;
2005-05-26 05:06:32 +04:00
}
return ;
failed :
2005-07-12 10:17:19 +04:00
stream_terminate_connection ( conn , " websrv_recv: failed " ) ;
2005-05-26 05:06:32 +04:00
}
/*
called when a web connection becomes writable
*/
static void websrv_send ( struct stream_connection * conn , uint16_t flags )
{
struct websrv_context * web = talloc_get_type ( conn - > private ,
struct websrv_context ) ;
NTSTATUS status ;
size_t nsent ;
DATA_BLOB b ;
b = web - > output . content ;
b . data + = web - > output . nsent ;
b . length - = web - > output . nsent ;
2006-05-03 00:15:47 +04:00
status = socket_send ( conn - > socket , & b , & nsent ) ;
2005-05-26 05:06:32 +04:00
if ( NT_STATUS_IS_ERR ( status ) ) {
stream_terminate_connection ( web - > conn , " socket_send: failed " ) ;
return ;
}
if ( ! NT_STATUS_IS_OK ( status ) ) {
return ;
}
web - > output . nsent + = nsent ;
/* possibly read some more raw data from a file */
if ( web - > output . content . length = = web - > output . nsent & &
web - > output . fd ! = - 1 ) {
uint8_t buf [ 2048 ] ;
ssize_t nread ;
data_blob_free ( & web - > output . content ) ;
web - > output . nsent = 0 ;
nread = read ( web - > output . fd , buf , sizeof ( buf ) ) ;
if ( nread = = - 1 & & errno = = EINTR ) {
return ;
}
2005-08-18 16:19:16 +04:00
if ( nread < = 0 ) {
close ( web - > output . fd ) ;
web - > output . fd = - 1 ;
nread = 0 ;
}
2005-05-26 05:06:32 +04:00
web - > output . content = data_blob_talloc ( web , buf , nread ) ;
}
2005-05-27 15:57:14 +04:00
if ( web - > output . content . length = = web - > output . nsent & &
web - > output . fd = = - 1 ) {
2005-07-12 10:17:19 +04:00
stream_terminate_connection ( web - > conn , " websrv_send: finished sending " ) ;
2005-05-26 05:06:32 +04:00
}
}
/*
establish a new connection to the web server
*/
static void websrv_accept ( struct stream_connection * conn )
{
2005-05-27 04:29:58 +04:00
struct task_server * task = talloc_get_type ( conn - > private , struct task_server ) ;
2005-06-19 08:21:45 +04:00
struct esp_data * edata = talloc_get_type ( task - > private , struct esp_data ) ;
2005-05-26 05:06:32 +04:00
struct websrv_context * web ;
2006-07-28 07:51:20 +04:00
struct socket_context * tls_socket ;
2005-05-26 05:06:32 +04:00
web = talloc_zero ( conn , struct websrv_context ) ;
if ( web = = NULL ) goto failed ;
2005-05-27 04:29:58 +04:00
web - > task = task ;
2005-05-26 05:06:32 +04:00
web - > conn = conn ;
conn - > private = web ;
web - > output . fd = - 1 ;
talloc_set_destructor ( web , websrv_destructor ) ;
event_add_timed ( conn - > event . ctx , web ,
timeval_current_ofs ( HTTP_TIMEOUT , 0 ) ,
websrv_timeout , web ) ;
2005-05-27 15:57:14 +04:00
2006-05-03 00:15:47 +04:00
/* Overwrite the socket with a (possibly) TLS socket */
2006-07-28 07:51:20 +04:00
tls_socket = tls_init_server ( edata - > tls_params , conn - > socket ,
conn - > event . fde , " GPHO " ) ;
/* We might not have TLS, or it might not have initilised */
if ( tls_socket ) {
talloc_unlink ( conn , conn - > socket ) ;
talloc_steal ( conn , tls_socket ) ;
conn - > socket = tls_socket ;
} else {
DEBUG ( 3 , ( " TLS not available for web_server connections \n " ) ) ;
}
2005-05-27 15:57:14 +04:00
2005-05-26 05:06:32 +04:00
return ;
failed :
talloc_free ( conn ) ;
}
static const struct stream_server_ops web_stream_ops = {
. name = " web " ,
. accept_connection = websrv_accept ,
. recv_handler = websrv_recv ,
. send_handler = websrv_send ,
} ;
/*
startup the web server task
*/
static void websrv_task_init ( struct task_server * task )
{
NTSTATUS status ;
2005-05-26 06:06:33 +04:00
uint16_t port = lp_web_port ( ) ;
2005-05-26 05:06:32 +04:00
const struct model_ops * model_ops ;
2006-03-09 20:48:41 +03:00
task_server_set_title ( task , " task[websrv] " ) ;
2005-05-26 05:06:32 +04:00
/* run the web server as a single process */
model_ops = process_model_byname ( " single " ) ;
if ( ! model_ops ) goto failed ;
if ( lp_interfaces ( ) & & lp_bind_interfaces_only ( ) ) {
int num_interfaces = iface_count ( ) ;
int i ;
for ( i = 0 ; i < num_interfaces ; i + + ) {
const char * address = iface_n_ip ( i ) ;
status = stream_setup_socket ( task - > event_ctx , model_ops ,
& web_stream_ops ,
" ipv4 " , address ,
& port , task ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) goto failed ;
}
} else {
status = stream_setup_socket ( task - > event_ctx , model_ops ,
& web_stream_ops ,
" ipv4 " , lp_socket_address ( ) ,
& port , task ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) goto failed ;
}
2005-05-27 04:29:58 +04:00
/* startup the esp processor - unfortunately we can't do this
per connection as that wouldn ' t allow for session variables */
status = http_setup_esp ( task ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) goto failed ;
2005-05-26 05:06:32 +04:00
return ;
failed :
2005-07-12 10:17:19 +04:00
task_server_terminate ( task , " websrv_task_init: failed to startup web server task " ) ;
2005-05-26 05:06:32 +04:00
}
/*
called on startup of the web server service It ' s job is to start
listening on all configured sockets
*/
static NTSTATUS websrv_init ( struct event_context * event_context ,
const struct model_ops * model_ops )
{
return task_server_startup ( event_context , model_ops , websrv_task_init ) ;
}
/* called at smbd startup - register ourselves as a server service */
NTSTATUS server_service_web_init ( void )
{
return register_server_service ( " web " , websrv_init ) ;
}