2006-09-19 19:58:09 +00:00
/*
2006-03-25 23:50:09 +00:00
* Asterisk - - An open source telephony toolkit .
*
* Copyright ( C ) 1999 - 2006 , Digium , Inc .
*
* Mark Spencer < markster @ digium . com >
*
* See http : //www.asterisk.org for more information about
* the Asterisk project . Please do not directly contact
* any of the maintainers of this project for assistance ;
* the project provides a web site , mailing lists and IRC
* channels for your use .
*
* This program is free software , distributed under the terms of
* the GNU General Public License Version 2. See the LICENSE file
* at the top of the source tree .
*/
2006-03-26 16:48:47 +00:00
/*!
2006-09-19 19:58:09 +00:00
* \ file
2006-04-03 18:38:28 +00:00
* \ brief http server for AMI access
2006-03-26 16:48:47 +00:00
*
2006-04-03 18:38:28 +00:00
* \ author Mark Spencer < markster @ digium . com >
2006-03-26 16:48:47 +00:00
* This program implements a tiny http server supporting the " get " method
2006-09-19 19:58:09 +00:00
* only and was inspired by micro - httpd by Jef Poskanzer
*
2006-04-03 18:38:28 +00:00
* \ ref AstHTTP - AMI over the http protocol
2006-03-26 16:48:47 +00:00
*/
2006-06-07 18:54:56 +00:00
# include "asterisk.h"
ASTERISK_FILE_VERSION ( __FILE__ , " $Revision$ " )
2006-03-25 23:50:09 +00:00
# include <sys/types.h>
# include <stdio.h>
# include <unistd.h>
# include <stdlib.h>
# include <time.h>
# include <string.h>
# include <netinet/in.h>
# include <sys/time.h>
# include <sys/socket.h>
2006-04-01 08:49:54 +00:00
# include <sys/stat.h>
2006-03-25 23:50:09 +00:00
# include <sys/signal.h>
# include <arpa/inet.h>
# include <errno.h>
# include <fcntl.h>
# include <pthread.h>
2006-03-26 16:48:47 +00:00
# include "asterisk/cli.h"
# include "asterisk/http.h"
# include "asterisk/utils.h"
# include "asterisk/strings.h"
2006-04-01 08:49:54 +00:00
# include "asterisk/options.h"
# include "asterisk/config.h"
2006-03-25 23:50:09 +00:00
# define MAX_PREFIX 80
2006-04-02 23:55:15 +00:00
# define DEFAULT_PREFIX " / asterisk"
2006-03-25 23:50:09 +00:00
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
/*!
* In order to have SSL support , we need the openssl libraries .
* Still we can decide whether or not to use them by commenting
* in or out the DO_SSL macro .
* We declare most of ssl support variables unconditionally ,
* because their number is small and this simplifies the code .
2006-11-25 17:37:04 +00:00
* XXX this eventually goes into a generic header file .
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
*/
2006-10-22 19:09:25 +00:00
# if defined(HAVE_OPENSSL) && (defined(HAVE_FUNOPEN) || defined(HAVE_FOPENCOOKIE))
# define DO_SSL /* comment in/out if you want to support ssl */
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
# endif
# ifdef DO_SSL
# include <openssl/ssl.h>
# include <openssl/err.h>
2006-11-27 18:51:10 +00:00
static SSL_CTX * ssl_ctx ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
# endif /* DO_SSL */
/* SSL support */
# define AST_CERTFILE "asterisk.pem"
static int do_ssl ;
static char * certfile ;
static char * cipher ;
/*!
* describes a server instance
*/
struct server_instance {
FILE * f ; /* fopen/funopen result */
int fd ; /* the socket returned by accept() */
int is_ssl ; /* is this an ssl session ? */
# ifdef DO_SSL
SSL * ssl ; /* ssl state */
# endif
2006-03-25 23:50:09 +00:00
struct sockaddr_in requestor ;
} ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
/*!
* arguments for the accepting thread
*/
struct server_args {
struct sockaddr_in sin ;
struct sockaddr_in oldsin ;
int is_ssl ; /* is this an SSL accept ? */
int accept_fd ;
pthread_t master ;
2006-11-25 17:37:04 +00:00
void * ( * accept_fn ) ( void * ) ; /* the function in charge of doing the accept */
void * ( * worker_fn ) ( void * ) ; /* the function in charge of doing the actual work */
const char * name ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
} ;
2006-11-25 17:37:04 +00:00
static void * http_root ( void * arg ) ;
static void * httpd_helper_thread ( void * arg ) ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
/*!
* we have up to two accepting threads , one for http , one for https
*/
static struct server_args http_desc = {
. accept_fd = - 1 ,
. master = AST_PTHREADT_NULL ,
. is_ssl = 0 ,
2006-11-25 17:37:04 +00:00
. name = " http server " ,
. accept_fn = http_root ,
. worker_fn = httpd_helper_thread ,
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
} ;
static struct server_args https_desc = {
. accept_fd = - 1 ,
. master = AST_PTHREADT_NULL ,
. is_ssl = 1 ,
2006-11-25 17:37:04 +00:00
. name = " https server " ,
. accept_fn = http_root ,
. worker_fn = httpd_helper_thread ,
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
} ;
2006-03-25 23:50:09 +00:00
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
static struct ast_http_uri * uris ; /*!< list of supported handlers */
2006-10-16 08:38:35 +00:00
/* all valid URIs must be prepended by the string in prefix. */
2006-03-25 23:50:09 +00:00
static char prefix [ MAX_PREFIX ] ;
2006-04-01 08:49:54 +00:00
static int enablestatic = 0 ;
2006-04-03 18:38:28 +00:00
/*! \brief Limit the kinds of files we're willing to serve up */
2006-04-01 08:49:54 +00:00
static struct {
char * ext ;
char * mtype ;
} mimetypes [ ] = {
{ " png " , " image/png " } ,
{ " jpg " , " image/jpeg " } ,
{ " js " , " application/x-javascript " } ,
{ " wav " , " audio/x-wav " } ,
{ " mp3 " , " audio/mpeg " } ,
} ;
static char * ftype2mtype ( const char * ftype , char * wkspace , int wkspacelen )
{
int x ;
if ( ftype ) {
for ( x = 0 ; x < sizeof ( mimetypes ) / sizeof ( mimetypes [ 0 ] ) ; x + + ) {
if ( ! strcasecmp ( ftype , mimetypes [ x ] . ext ) )
return mimetypes [ x ] . mtype ;
}
}
snprintf ( wkspace , wkspacelen , " text/%s " , ftype ? ftype : " plain " ) ;
return wkspace ;
}
2006-10-18 05:27:22 +00:00
/* like ast_uri_decode, but replace '+' with ' ' */
static char * uri_decode ( char * buf )
{
char * c ;
ast_uri_decode ( buf ) ;
for ( c = buf ; * c ; c + + ) {
if ( * c = = ' + ' )
* c = ' ' ;
}
return buf ;
}
2006-04-01 08:49:54 +00:00
static char * static_callback ( struct sockaddr_in * req , const char * uri , struct ast_variable * vars , int * status , char * * title , int * contentlength )
{
char result [ 4096 ] ;
char * c = result ;
char * path ;
char * ftype , * mtype ;
char wkspace [ 80 ] ;
struct stat st ;
int len ;
int fd ;
void * blob ;
2006-09-19 19:58:09 +00:00
/* Yuck. I'm not really sold on this, but if you don't deliver static content it makes your configuration
2006-04-01 08:49:54 +00:00
substantially more challenging , but this seems like a rather irritating feature creep on Asterisk . */
if ( ! enablestatic | | ast_strlen_zero ( uri ) )
goto out403 ;
/* Disallow any funny filenames at all */
if ( ( uri [ 0 ] < 33 ) | | strchr ( " ./|~@#$%^&*() \t " , uri [ 0 ] ) )
goto out403 ;
if ( strstr ( uri , " /.. " ) )
goto out403 ;
2006-09-19 19:58:09 +00:00
2006-04-01 08:49:54 +00:00
if ( ( ftype = strrchr ( uri , ' . ' ) ) )
ftype + + ;
mtype = ftype2mtype ( ftype , wkspace , sizeof ( wkspace ) ) ;
2006-09-19 19:58:09 +00:00
2006-04-01 08:49:54 +00:00
/* Cap maximum length */
2006-04-15 22:53:53 +00:00
len = strlen ( uri ) + strlen ( ast_config_AST_DATA_DIR ) + strlen ( " /static-http/ " ) + 5 ;
2006-04-01 08:49:54 +00:00
if ( len > 1024 )
goto out403 ;
2006-09-19 19:58:09 +00:00
2006-04-01 08:49:54 +00:00
path = alloca ( len ) ;
2006-04-15 22:53:53 +00:00
sprintf ( path , " %s/static-http/%s " , ast_config_AST_DATA_DIR , uri ) ;
2006-04-01 08:49:54 +00:00
if ( stat ( path , & st ) )
goto out404 ;
if ( S_ISDIR ( st . st_mode ) )
goto out404 ;
fd = open ( path , O_RDONLY ) ;
if ( fd < 0 )
goto out403 ;
2006-09-19 19:58:09 +00:00
2006-04-01 08:49:54 +00:00
len = st . st_size + strlen ( mtype ) + 40 ;
2006-09-19 19:58:09 +00:00
2006-04-01 08:49:54 +00:00
blob = malloc ( len ) ;
if ( blob ) {
c = blob ;
sprintf ( c , " Content-type: %s \r \n \r \n " , mtype ) ;
c + = strlen ( c ) ;
* contentlength = read ( fd , c , st . st_size ) ;
if ( * contentlength < 0 ) {
close ( fd ) ;
free ( blob ) ;
goto out403 ;
}
}
2006-07-18 20:26:38 +00:00
close ( fd ) ;
2006-04-01 08:49:54 +00:00
return blob ;
out404 :
* status = 404 ;
* title = strdup ( " Not Found " ) ;
return ast_http_error ( 404 , " Not Found " , NULL , " Nothing to see here. Move along. " ) ;
out403 :
* status = 403 ;
* title = strdup ( " Access Denied " ) ;
return ast_http_error ( 403 , " Access Denied " , NULL , " Sorry, I cannot let you do that, Dave. " ) ;
}
2006-03-25 23:50:09 +00:00
static char * httpstatus_callback ( struct sockaddr_in * req , const char * uri , struct ast_variable * vars , int * status , char * * title , int * contentlength )
{
char result [ 4096 ] ;
2006-03-26 06:59:10 +00:00
size_t reslen = sizeof ( result ) ;
2006-03-25 23:50:09 +00:00
char * c = result ;
struct ast_variable * v ;
ast_build_string ( & c , & reslen ,
" \r \n "
" <title>Asterisk HTTP Status</title> \r \n "
" <body bgcolor= \" #ffffff \" > \r \n "
" <table bgcolor= \" #f1f1f1 \" align= \" center \" ><tr><td bgcolor= \" #e0e0ff \" colspan= \" 2 \" width= \" 500 \" > \r \n "
" <h2> Asterisk™ HTTP Status</h2></td></tr> \r \n " ) ;
ast_build_string ( & c , & reslen , " <tr><td><i>Prefix</i></td><td><b>%s</b></td></tr> \r \n " , prefix ) ;
ast_build_string ( & c , & reslen , " <tr><td><i>Bind Address</i></td><td><b>%s</b></td></tr> \r \n " ,
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
ast_inet_ntoa ( http_desc . oldsin . sin_addr ) ) ;
2006-03-25 23:50:09 +00:00
ast_build_string ( & c , & reslen , " <tr><td><i>Bind Port</i></td><td><b>%d</b></td></tr> \r \n " ,
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
ntohs ( http_desc . oldsin . sin_port ) ) ;
if ( do_ssl )
ast_build_string ( & c , & reslen , " <tr><td><i>SSL Bind Port</i></td><td><b>%d</b></td></tr> \r \n " ,
ntohs ( https_desc . oldsin . sin_port ) ) ;
2006-03-25 23:50:09 +00:00
ast_build_string ( & c , & reslen , " <tr><td colspan= \" 2 \" ><hr></td></tr> \r \n " ) ;
v = vars ;
while ( v ) {
2006-04-01 08:49:54 +00:00
if ( strncasecmp ( v - > name , " cookie_ " , 7 ) )
ast_build_string ( & c , & reslen , " <tr><td><i>Submitted Variable '%s'</i></td><td>%s</td></tr> \r \n " , v - > name , v - > value ) ;
v = v - > next ;
}
ast_build_string ( & c , & reslen , " <tr><td colspan= \" 2 \" ><hr></td></tr> \r \n " ) ;
v = vars ;
while ( v ) {
if ( ! strncasecmp ( v - > name , " cookie_ " , 7 ) )
ast_build_string ( & c , & reslen , " <tr><td><i>Cookie '%s'</i></td><td>%s</td></tr> \r \n " , v - > name , v - > value ) ;
2006-03-25 23:50:09 +00:00
v = v - > next ;
}
ast_build_string ( & c , & reslen , " </table><center><font size= \" -1 \" ><i>Asterisk and Digium are registered trademarks of Digium, Inc.</i></font></center></body> \r \n " ) ;
return strdup ( result ) ;
}
static struct ast_http_uri statusuri = {
. callback = httpstatus_callback ,
. description = " Asterisk HTTP General Status " ,
. uri = " httpstatus " ,
. has_subtree = 0 ,
} ;
2006-09-19 19:58:09 +00:00
2006-04-01 08:49:54 +00:00
static struct ast_http_uri staticuri = {
. callback = static_callback ,
. description = " Asterisk HTTP Static Delivery " ,
. uri = " static " ,
. has_subtree = 1 ,
} ;
2006-09-19 19:58:09 +00:00
2006-03-25 23:50:09 +00:00
char * ast_http_error ( int status , const char * title , const char * extra_header , const char * text )
{
char * c = NULL ;
asprintf ( & c ,
" Content-type: text/html \r \n "
" %s "
" \r \n "
" <!DOCTYPE HTML PUBLIC \" -//IETF//DTD HTML 2.0//EN \" > \r \n "
" <html><head> \r \n "
" <title>%d %s</title> \r \n "
" </head><body> \r \n "
" <h1>%s</h1> \r \n "
" <p>%s</p> \r \n "
" <hr /> \r \n "
" <address>Asterisk Server</address> \r \n "
" </body></html> \r \n " ,
( extra_header ? extra_header : " " ) , status , title , title , text ) ;
return c ;
}
2006-10-16 08:38:35 +00:00
/*! \brief
* Link the new uri into the list . They are sorted by length of
* the string , not alphabetically . Duplicate entries are not replaced ,
* but the insertion order ( using < = and not just < ) makes sure that
* more recent insertions hide older ones .
* On a lookup , we just scan the list and stop at the first matching entry .
*/
2006-03-25 23:50:09 +00:00
int ast_http_uri_link ( struct ast_http_uri * urih )
{
struct ast_http_uri * prev = uris ;
2006-10-16 08:38:35 +00:00
int len = strlen ( urih - > uri ) ;
if ( ! uris | | strlen ( uris - > uri ) < = len ) {
2006-03-25 23:50:09 +00:00
urih - > next = uris ;
uris = urih ;
} else {
2006-10-16 08:38:35 +00:00
while ( prev - > next & & strlen ( prev - > next - > uri ) > len )
2006-03-25 23:50:09 +00:00
prev = prev - > next ;
/* Insert it here */
urih - > next = prev - > next ;
prev - > next = urih ;
}
return 0 ;
2006-09-19 19:58:09 +00:00
}
2006-03-25 23:50:09 +00:00
void ast_http_uri_unlink ( struct ast_http_uri * urih )
{
struct ast_http_uri * prev = uris ;
if ( ! uris )
return ;
if ( uris = = urih ) {
uris = uris - > next ;
}
while ( prev - > next ) {
if ( prev - > next = = urih ) {
prev - > next = urih - > next ;
break ;
}
prev = prev - > next ;
}
}
2006-04-01 08:49:54 +00:00
static char * handle_uri ( struct sockaddr_in * sin , char * uri , int * status , char * * title , int * contentlength , struct ast_variable * * cookies )
2006-03-25 23:50:09 +00:00
{
char * c ;
2006-10-18 04:05:56 +00:00
char * params = uri ;
2006-03-25 23:50:09 +00:00
struct ast_http_uri * urih = NULL ;
2006-10-18 04:05:56 +00:00
int l ;
2006-03-25 23:50:09 +00:00
struct ast_variable * vars = NULL , * v , * prev = NULL ;
2006-10-16 08:38:35 +00:00
2006-10-18 04:05:56 +00:00
strsep ( & params , " ? " ) ;
2006-10-16 08:38:35 +00:00
/* Extract arguments from the request and store them in variables. */
2006-03-25 23:50:09 +00:00
if ( params ) {
2006-10-16 08:38:35 +00:00
char * var , * val ;
2006-10-18 04:05:56 +00:00
while ( ( val = strsep ( & params , " & " ) ) ) {
var = strsep ( & val , " = " ) ;
if ( val )
2006-10-18 05:27:22 +00:00
uri_decode ( val ) ;
2006-10-18 04:05:56 +00:00
else
2006-03-25 23:50:09 +00:00
val = " " ;
ast_uri_decode ( var ) ;
if ( ( v = ast_variable_new ( var , val ) ) ) {
if ( vars )
prev - > next = v ;
else
vars = v ;
prev = v ;
}
}
}
2006-10-16 08:38:35 +00:00
/*
* Append the cookies to the variables ( the only reason to have them
* at the end is to avoid another pass of the cookies list to find
2006-10-18 04:05:56 +00:00
* the tail ) .
2006-10-16 08:38:35 +00:00
*/
2006-04-01 08:49:54 +00:00
if ( prev )
prev - > next = * cookies ;
else
vars = * cookies ;
* cookies = NULL ;
2006-03-25 23:50:09 +00:00
ast_uri_decode ( uri ) ;
2006-10-16 08:38:35 +00:00
/* We want requests to start with the prefix and '/' */
2006-10-18 04:05:56 +00:00
l = strlen ( prefix ) ;
if ( l & & ! strncasecmp ( uri , prefix , l ) & & uri [ l ] = = ' / ' ) {
uri + = l + 1 ;
2006-10-16 08:38:35 +00:00
/* scan registered uris to see if we match one. */
for ( urih = uris ; urih ; urih = urih - > next ) {
2006-10-18 04:05:56 +00:00
l = strlen ( urih - > uri ) ;
c = uri + l ; /* candidate */
if ( strncasecmp ( urih - > uri , uri , l ) /* no match */
| | ( * c & & * c ! = ' / ' ) ) /* substring */
continue ;
if ( * c = = ' / ' )
c + + ;
if ( ! * c | | urih - > has_subtree ) {
uri = c ;
break ;
2006-03-25 23:50:09 +00:00
}
}
}
if ( urih ) {
c = urih - > callback ( sin , uri , vars , status , title , contentlength ) ;
2006-04-02 09:10:43 +00:00
} else if ( ast_strlen_zero ( uri ) & & ast_strlen_zero ( prefix ) ) {
2006-10-18 04:05:56 +00:00
/* Special case: no prefix, no URI, send to /static/index.html */
c = ast_http_error ( 302 , " Moved Temporarily " ,
" Location: /static/index.html \r \n " ,
" This is not the page you are looking for... " ) ;
2006-04-02 09:10:43 +00:00
* status = 302 ;
* title = strdup ( " Moved Temporarily " ) ;
2006-03-25 23:50:09 +00:00
} else {
2006-10-18 04:05:56 +00:00
c = ast_http_error ( 404 , " Not Found " , NULL ,
" The requested URL was not found on this server. " ) ;
2006-03-25 23:50:09 +00:00
* status = 404 ;
* title = strdup ( " Not Found " ) ;
}
2006-10-18 04:05:56 +00:00
ast_variables_destroy ( vars ) ;
2006-03-25 23:50:09 +00:00
return c ;
}
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
# ifdef DO_SSL
2006-10-22 19:09:25 +00:00
# if defined(HAVE_FUNOPEN)
# define HOOK_T int
# define LEN_T int
# else
# define HOOK_T ssize_t
# define LEN_T size_t
# endif
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
/*!
* replacement read / write functions for SSL support .
* We use wrappers rather than SSL_read / SSL_write directly so
* we can put in some debugging .
*/
2006-10-22 19:09:25 +00:00
static HOOK_T ssl_read ( void * cookie , char * buf , LEN_T len )
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
{
2006-10-22 19:09:25 +00:00
int i = SSL_read ( cookie , buf , len - 1 ) ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
#if 0
if ( i > = 0 )
buf [ i ] = ' \0 ' ;
2006-10-22 19:09:25 +00:00
ast_verbose ( " ssl read size %d returns %d <%s> \n " , ( int ) len , i , buf ) ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
# endif
return i ;
}
2006-10-22 19:09:25 +00:00
static HOOK_T ssl_write ( void * cookie , const char * buf , LEN_T len )
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
{
#if 0
char * s = alloca ( len + 1 ) ;
strncpy ( s , buf , len ) ;
s [ len ] = ' \0 ' ;
2006-10-22 19:09:25 +00:00
ast_verbose ( " ssl write size %d <%s> \n " , ( int ) len , s ) ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
# endif
return SSL_write ( cookie , buf , len ) ;
}
static int ssl_close ( void * cookie )
{
close ( SSL_get_fd ( cookie ) ) ;
SSL_shutdown ( cookie ) ;
SSL_free ( cookie ) ;
return 0 ;
}
2006-10-22 19:09:25 +00:00
# endif /* DO_SSL */
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
2006-11-25 17:37:04 +00:00
static void * httpd_helper_thread ( void * data )
2006-03-25 23:50:09 +00:00
{
char buf [ 4096 ] ;
2006-04-01 08:49:54 +00:00
char cookie [ 4096 ] ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
struct server_instance * ser = data ;
2006-04-01 08:49:54 +00:00
struct ast_variable * var , * prev = NULL , * vars = NULL ;
2006-03-25 23:50:09 +00:00
char * uri , * c , * title = NULL ;
int status = 200 , contentlength = 0 ;
2006-10-22 19:09:25 +00:00
/*
* open a FILE * as appropriate .
*/
if ( ! ser - > is_ssl )
ser - > f = fdopen ( ser - > fd , " w+ " ) ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
# ifdef DO_SSL
2006-10-22 19:09:25 +00:00
else if ( ( ser - > ssl = SSL_new ( ssl_ctx ) ) ) {
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
SSL_set_fd ( ser - > ssl , ser - > fd ) ;
2006-10-22 19:09:25 +00:00
if ( SSL_accept ( ser - > ssl ) = = 0 )
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
ast_verbose ( " error setting up ssl connection " ) ;
2006-10-22 19:09:25 +00:00
else {
# if defined(HAVE_FUNOPEN) /* the BSD interface */
ser - > f = funopen ( ser - > ssl , ssl_read , ssl_write , NULL , ssl_close ) ;
# elif defined(HAVE_FOPENCOOKIE) /* the glibc/linux interface */
static const cookie_io_functions_t cookie_funcs = {
ssl_read , ssl_write , NULL , ssl_close
} ;
ser - > f = fopencookie ( ser - > ssl , " w+ " , cookie_funcs ) ;
# else
/* could add other methods here */
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
# endif
2006-10-22 19:09:25 +00:00
}
if ( ! ser - > f ) /* no success opening descriptor stacking */
SSL_free ( ser - > ssl ) ;
}
# endif /* DO_SSL */
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
if ( ! ser - > f ) {
close ( ser - > fd ) ;
2006-10-22 19:09:25 +00:00
ast_log ( LOG_WARNING , " FILE * open failed! \n " ) ;
goto done ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
}
2006-10-18 04:05:56 +00:00
if ( ! fgets ( buf , sizeof ( buf ) , ser - > f ) )
goto done ;
2006-03-25 23:50:09 +00:00
2006-10-18 04:05:56 +00:00
uri = ast_skip_nonblanks ( buf ) ; /* Skip method */
if ( * uri )
* uri + + = ' \0 ' ;
2006-03-25 23:50:09 +00:00
2006-10-18 04:05:56 +00:00
uri = ast_skip_blanks ( uri ) ; /* Skip white space */
2006-04-01 08:49:54 +00:00
2006-10-18 04:05:56 +00:00
if ( * uri ) { /* terminate at the first blank */
c = ast_skip_nonblanks ( uri ) ;
if ( * c )
* c = ' \0 ' ;
}
/* process "Cookie: " lines */
while ( fgets ( cookie , sizeof ( cookie ) , ser - > f ) ) {
char * vname , * vval ;
int l ;
2006-10-16 06:30:51 +00:00
2006-10-18 04:05:56 +00:00
/* Trim trailing characters */
ast_trim_blanks ( cookie ) ;
if ( ast_strlen_zero ( cookie ) )
break ;
if ( strncasecmp ( cookie , " Cookie: " , 8 ) )
continue ;
2006-08-17 04:26:28 +00:00
2006-10-18 04:05:56 +00:00
/* TODO - The cookie parsing code below seems to work
in IE6 and FireFox 1.5 . However , it is not entirely
correct , and therefore may not work in all
circumstances .
For more details see RFC 2109 and RFC 2965 */
/* FireFox cookie strings look like:
Cookie : mansession_id = " ******** "
InternetExplorer ' s look like :
Cookie : $ Version = " 1 " ; mansession_id = " ******** " */
2006-10-16 06:55:14 +00:00
2006-10-18 04:05:56 +00:00
/* If we got a FireFox cookie string, the name's right
after " Cookie: " */
vname = ast_skip_blanks ( cookie + 8 ) ;
2006-09-19 19:58:09 +00:00
2006-10-18 04:05:56 +00:00
/* If we got an IE cookie string, we need to skip to
past the version to get to the name */
if ( * vname = = ' $ ' ) {
strsep ( & vname , " ; " ) ;
if ( ! vname ) /* no name ? */
continue ;
vname = ast_skip_blanks ( vname ) ;
2006-04-01 08:49:54 +00:00
}
2006-10-18 04:05:56 +00:00
vval = strchr ( vname , ' = ' ) ;
if ( ! vval )
continue ;
/* Ditch the = and the quotes */
* vval + + = ' \0 ' ;
if ( * vval )
vval + + ;
if ( ( l = strlen ( vval ) ) )
vval [ l - 1 ] = ' \0 ' ; /* trim trailing quote */
var = ast_variable_new ( vname , vval ) ;
if ( var ) {
if ( prev )
prev - > next = var ;
else
vars = var ;
prev = var ;
2006-03-25 23:50:09 +00:00
}
}
2006-10-18 04:05:56 +00:00
if ( ! * uri )
c = ast_http_error ( 400 , " Bad Request " , NULL , " Invalid Request " ) ;
else if ( strcasecmp ( buf , " get " ) )
c = ast_http_error ( 501 , " Not Implemented " , NULL ,
" Attempt to use unimplemented / unsupported method " ) ;
else /* try to serve it */
c = handle_uri ( & ser - > requestor , uri , & status , & title , & contentlength , & vars ) ;
/* 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 t = time ( NULL ) ;
char timebuf [ 256 ] ;
strftime ( timebuf , sizeof ( timebuf ) , " %a, %d %b %Y %H:%M:%S GMT " , gmtime ( & t ) ) ;
2006-10-22 08:28:16 +00:00
fprintf ( ser - > f , " HTTP/1.1 %d %s \r \n "
" Server: Asterisk \r \n "
" Date: %s \r \n "
" Connection: close \r \n " ,
status , title ? title : " OK " , timebuf ) ;
if ( ! contentlength ) { /* opaque body ? just dump it hoping it is properly formatted */
fprintf ( ser - > f , " %s " , c ) ;
} else {
2006-10-18 04:05:56 +00:00
char * tmp = strstr ( c , " \r \n \r \n " ) ;
if ( tmp ) {
2006-10-22 08:28:16 +00:00
fprintf ( ser - > f , " Content-length: %d \r \n " , contentlength ) ;
2006-10-18 04:05:56 +00:00
/* first write the header, then the body */
2006-10-22 08:28:16 +00:00
fwrite ( c , 1 , ( tmp + 4 - c ) , ser - > f ) ;
fwrite ( tmp + 4 , 1 , contentlength , ser - > f ) ;
2006-10-18 04:05:56 +00:00
}
2006-10-22 08:28:16 +00:00
}
2006-10-18 04:05:56 +00:00
free ( c ) ;
}
if ( title )
free ( title ) ;
done :
2006-10-22 19:09:25 +00:00
if ( ser - > f )
fclose ( ser - > f ) ;
2006-03-25 23:50:09 +00:00
free ( ser ) ;
return NULL ;
}
static void * http_root ( void * data )
{
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
struct server_args * desc = data ;
2006-03-25 23:50:09 +00:00
int fd ;
struct sockaddr_in sin ;
2006-07-07 06:57:02 +00:00
socklen_t sinlen ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
struct server_instance * ser ;
2006-03-25 23:50:09 +00:00
pthread_t launched ;
2006-04-02 23:55:15 +00:00
pthread_attr_t attr ;
2006-09-19 19:58:09 +00:00
2006-03-25 23:50:09 +00:00
for ( ; ; ) {
2006-10-15 20:54:15 +00:00
int flags ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
ast_wait_for_input ( desc - > accept_fd , - 1 ) ;
2006-03-25 23:50:09 +00:00
sinlen = sizeof ( sin ) ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
fd = accept ( desc - > accept_fd , ( struct sockaddr * ) & sin , & sinlen ) ;
2006-03-25 23:50:09 +00:00
if ( fd < 0 ) {
if ( ( errno ! = EAGAIN ) & & ( errno ! = EINTR ) )
ast_log ( LOG_WARNING , " Accept failed: %s \n " , strerror ( errno ) ) ;
continue ;
}
2006-04-01 08:49:54 +00:00
ser = ast_calloc ( 1 , sizeof ( * ser ) ) ;
2006-10-15 20:54:15 +00:00
if ( ! ser ) {
ast_log ( LOG_WARNING , " No memory for new session: %s \n " , strerror ( errno ) ) ;
close ( fd ) ;
continue ;
}
flags = fcntl ( fd , F_GETFL ) ;
fcntl ( fd , F_SETFL , flags & ~ O_NONBLOCK ) ;
ser - > fd = fd ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
ser - > is_ssl = desc - > is_ssl ;
2006-10-15 20:54:15 +00:00
memcpy ( & ser - > requestor , & sin , sizeof ( ser - > requestor ) ) ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
pthread_attr_init ( & attr ) ;
pthread_attr_setdetachstate ( & attr , PTHREAD_CREATE_DETACHED ) ;
2006-10-15 20:54:15 +00:00
2006-11-25 17:37:04 +00:00
if ( ast_pthread_create_background ( & launched , & attr , desc - > worker_fn , ser ) ) {
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
ast_log ( LOG_WARNING , " Unable to launch helper thread: %s \n " , strerror ( errno ) ) ;
2006-10-15 20:54:15 +00:00
close ( ser - > fd ) ;
free ( ser ) ;
2006-03-25 23:50:09 +00:00
}
}
return NULL ;
}
2006-04-03 18:38:28 +00:00
char * ast_http_setcookie ( const char * var , const char * val , int expires , char * buf , size_t buflen )
2006-04-01 08:49:54 +00:00
{
char * c ;
c = buf ;
ast_build_string ( & c , & buflen , " Set-Cookie: %s= \" %s \" ; Version= \" 1 \" " , var , val ) ;
if ( expires )
ast_build_string ( & c , & buflen , " ; Max-Age=%d " , expires ) ;
ast_build_string ( & c , & buflen , " \r \n " ) ;
return buf ;
}
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
static int ssl_setup ( void )
{
# ifndef DO_SSL
do_ssl = 0 ;
return 0 ;
# else
if ( ! do_ssl )
return 0 ;
SSL_load_error_strings ( ) ;
SSLeay_add_ssl_algorithms ( ) ;
ssl_ctx = SSL_CTX_new ( SSLv23_server_method ( ) ) ;
if ( ! ast_strlen_zero ( certfile ) ) {
if ( SSL_CTX_use_certificate_file ( ssl_ctx , certfile , SSL_FILETYPE_PEM ) = = 0 | |
SSL_CTX_use_PrivateKey_file ( ssl_ctx , certfile , SSL_FILETYPE_PEM ) = = 0 | |
SSL_CTX_check_private_key ( ssl_ctx ) = = 0 ) {
ast_verbose ( " ssl cert error <%s> " , certfile ) ;
sleep ( 2 ) ;
do_ssl = 0 ;
return 0 ;
}
}
if ( ! ast_strlen_zero ( cipher ) ) {
if ( SSL_CTX_set_cipher_list ( ssl_ctx , cipher ) = = 0 ) {
ast_verbose ( " ssl cipher error <%s> " , cipher ) ;
sleep ( 2 ) ;
do_ssl = 0 ;
return 0 ;
}
}
ast_verbose ( " ssl cert ok " ) ;
return 1 ;
# endif
}
2006-04-01 08:49:54 +00:00
2006-11-25 17:37:04 +00:00
/*!
* This is a generic ( re ) start routine for a TCP server ,
* which does the socket / bind / listen and starts a thread for handling
* accept ( ) .
*/
static void server_start ( struct server_args * desc )
2006-03-25 23:50:09 +00:00
{
int flags ;
int x = 1 ;
2006-09-19 19:58:09 +00:00
2006-03-25 23:50:09 +00:00
/* Do nothing if nothing has changed */
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
if ( ! memcmp ( & desc - > oldsin , & desc - > sin , sizeof ( desc - > oldsin ) ) ) {
2006-10-03 15:53:07 +00:00
if ( option_debug )
2006-11-25 17:37:04 +00:00
ast_log ( LOG_DEBUG , " Nothing changed in %s \n " , desc - > name ) ;
2006-03-25 23:50:09 +00:00
return ;
}
2006-09-19 19:58:09 +00:00
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
desc - > oldsin = desc - > sin ;
2006-09-19 19:58:09 +00:00
2006-03-25 23:50:09 +00:00
/* Shutdown a running server if there is one */
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
if ( desc - > master ! = AST_PTHREADT_NULL ) {
pthread_cancel ( desc - > master ) ;
pthread_kill ( desc - > master , SIGURG ) ;
pthread_join ( desc - > master , NULL ) ;
2006-03-25 23:50:09 +00:00
}
2006-09-19 19:58:09 +00:00
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
if ( desc - > accept_fd ! = - 1 )
close ( desc - > accept_fd ) ;
2006-03-25 23:50:09 +00:00
/* If there's no new server, stop here */
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
if ( desc - > sin . sin_family = = 0 )
2006-03-25 23:50:09 +00:00
return ;
2006-11-25 17:37:04 +00:00
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
desc - > accept_fd = socket ( AF_INET , SOCK_STREAM , 0 ) ;
if ( desc - > accept_fd < 0 ) {
2006-11-25 17:37:04 +00:00
ast_log ( LOG_WARNING , " Unable to allocate socket for %s: %s \n " ,
desc - > name , strerror ( errno ) ) ;
2006-03-25 23:50:09 +00:00
return ;
}
2006-09-19 19:58:09 +00:00
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
setsockopt ( desc - > accept_fd , SOL_SOCKET , SO_REUSEADDR , & x , sizeof ( x ) ) ;
if ( bind ( desc - > accept_fd , ( struct sockaddr * ) & desc - > sin , sizeof ( desc - > sin ) ) ) {
2006-11-25 17:37:04 +00:00
ast_log ( LOG_NOTICE , " Unable to bind %s to %s:%d: %s \n " ,
desc - > name ,
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
ast_inet_ntoa ( desc - > sin . sin_addr ) , ntohs ( desc - > sin . sin_port ) ,
2006-03-25 23:50:09 +00:00
strerror ( errno ) ) ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
goto error ;
2006-03-25 23:50:09 +00:00
}
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
if ( listen ( desc - > accept_fd , 10 ) ) {
2006-11-25 17:37:04 +00:00
ast_log ( LOG_NOTICE , " Unable to listen for %s! \n " , desc - > name ) ;
goto error ;
2006-03-25 23:50:09 +00:00
}
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
flags = fcntl ( desc - > accept_fd , F_GETFL ) ;
fcntl ( desc - > accept_fd , F_SETFL , flags | O_NONBLOCK ) ;
2006-11-25 17:37:04 +00:00
if ( ast_pthread_create_background ( & desc - > master , NULL , desc - > accept_fn , desc ) ) {
ast_log ( LOG_NOTICE , " Unable to launch %s on %s:%d: %s \n " ,
desc - > name ,
ast_inet_ntoa ( desc - > sin . sin_addr ) , ntohs ( desc - > sin . sin_port ) ,
strerror ( errno ) ) ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
goto error ;
2006-03-25 23:50:09 +00:00
}
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
return ;
error :
close ( desc - > accept_fd ) ;
desc - > accept_fd = - 1 ;
2006-03-25 23:50:09 +00:00
}
static int __ast_http_load ( int reload )
{
struct ast_config * cfg ;
struct ast_variable * v ;
int enabled = 0 ;
2006-04-01 08:49:54 +00:00
int newenablestatic = 0 ;
2006-03-25 23:50:09 +00:00
struct hostent * hp ;
struct ast_hostent ahp ;
char newprefix [ MAX_PREFIX ] ;
2006-04-03 18:38:28 +00:00
2006-11-25 17:37:04 +00:00
/* default values */
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
memset ( & http_desc . sin , 0 , sizeof ( http_desc . sin ) ) ;
http_desc . sin . sin_port = htons ( 8088 ) ;
2006-11-25 17:37:04 +00:00
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
memset ( & https_desc . sin , 0 , sizeof ( https_desc . sin ) ) ;
https_desc . sin . sin_port = htons ( 8089 ) ;
2006-03-25 23:50:09 +00:00
strcpy ( newprefix , DEFAULT_PREFIX ) ;
cfg = ast_config_load ( " http.conf " ) ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
do_ssl = 0 ;
if ( certfile )
free ( certfile ) ;
certfile = ast_strdup ( AST_CERTFILE ) ;
if ( cipher )
free ( cipher ) ;
cipher = ast_strdup ( " " ) ;
2006-03-25 23:50:09 +00:00
if ( cfg ) {
v = ast_variable_browse ( cfg , " general " ) ;
while ( v ) {
if ( ! strcasecmp ( v - > name , " enabled " ) )
enabled = ast_true ( v - > value ) ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
else if ( ! strcasecmp ( v - > name , " sslenable " ) )
do_ssl = ast_true ( v - > value ) ;
else if ( ! strcasecmp ( v - > name , " sslbindport " ) )
https_desc . sin . sin_port = htons ( atoi ( v - > value ) ) ;
else if ( ! strcasecmp ( v - > name , " sslcert " ) ) {
free ( certfile ) ;
certfile = ast_strdup ( v - > value ) ;
} else if ( ! strcasecmp ( v - > name , " sslcipher " ) ) {
free ( cipher ) ;
cipher = ast_strdup ( v - > value ) ;
}
2006-04-01 08:49:54 +00:00
else if ( ! strcasecmp ( v - > name , " enablestatic " ) )
newenablestatic = ast_true ( v - > value ) ;
2006-03-25 23:50:09 +00:00
else if ( ! strcasecmp ( v - > name , " bindport " ) )
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
http_desc . sin . sin_port = htons ( atoi ( v - > value ) ) ;
2006-03-25 23:50:09 +00:00
else if ( ! strcasecmp ( v - > name , " bindaddr " ) ) {
if ( ( hp = ast_gethostbyname ( v - > value , & ahp ) ) ) {
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
memcpy ( & http_desc . sin . sin_addr , hp - > h_addr , sizeof ( http_desc . sin . sin_addr ) ) ;
memcpy ( & https_desc . sin . sin_addr , hp - > h_addr , sizeof ( https_desc . sin . sin_addr ) ) ;
2006-03-25 23:50:09 +00:00
} else {
ast_log ( LOG_WARNING , " Invalid bind address '%s' \n " , v - > value ) ;
}
2006-04-02 09:10:43 +00:00
} else if ( ! strcasecmp ( v - > name , " prefix " ) ) {
if ( ! ast_strlen_zero ( v - > value ) ) {
newprefix [ 0 ] = ' / ' ;
ast_copy_string ( newprefix + 1 , v - > value , sizeof ( newprefix ) - 1 ) ;
} else {
newprefix [ 0 ] = ' \0 ' ;
}
2006-09-19 19:58:09 +00:00
2006-04-02 09:10:43 +00:00
}
2006-03-25 23:50:09 +00:00
v = v - > next ;
}
ast_config_destroy ( cfg ) ;
}
if ( enabled )
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
http_desc . sin . sin_family = https_desc . sin . sin_family = AF_INET ;
2006-10-16 08:38:35 +00:00
if ( strcmp ( prefix , newprefix ) )
2006-03-25 23:50:09 +00:00
ast_copy_string ( prefix , newprefix , sizeof ( prefix ) ) ;
2006-04-01 08:49:54 +00:00
enablestatic = newenablestatic ;
2006-11-25 17:37:04 +00:00
server_start ( & http_desc ) ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
if ( ssl_setup ( ) )
2006-11-25 17:37:04 +00:00
server_start ( & https_desc ) ;
2006-03-25 23:50:09 +00:00
return 0 ;
}
static int handle_show_http ( int fd , int argc , char * argv [ ] )
{
struct ast_http_uri * urih ;
2006-04-14 04:59:11 +00:00
if ( argc ! = 3 )
2006-03-25 23:50:09 +00:00
return RESULT_SHOWUSAGE ;
ast_cli ( fd , " HTTP Server Status: \n " ) ;
ast_cli ( fd , " Prefix: %s \n " , prefix ) ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
if ( ! http_desc . oldsin . sin_family )
2006-03-25 23:50:09 +00:00
ast_cli ( fd , " Server Disabled \n \n " ) ;
Implement https support.
The changes are not large. Most of the diff comes from putting the
global variables describing an accept session into a structure, so
we can reuse the existing code for running multiple accept threads
on different ports.
Once this is done, and if your system has the funopen() library
function (and ssl, of course), it is just a matter of calling
the appropriate functions to set up the ssl connection on the
existing socket, and everything works on the secure channel now.
At the moment, the code is disabled because i have not implemented yet
the autoconf code to detect the presence of funopen(), and add -lssl
to main/Makefile if ssl libraries are present. And a bit of documentation
on the http.conf arguments, too.
If you want to manually enable https support, that is very simple
(step 0 1 2 will be eventually detected by ./configure, the
rest is something you will have to do anyways).
0. make sure your system has funopen(3). FreeBSD does, linux probably
does too, not sure about other systems.
1. uncomment the following line in main/http.c
// #define DO_SSL /* comment in/out if you want to support ssl */
2. add -lssl to AST_LIBS in main/Makefile
3. add the following options to http.conf
sslenable=yes
sslbindport=4433 ; pick one you like
sslcert=/tmp/foo.pem ; path to your certificate file.
4. generate a suitable certificate e.g. (example from mini_httpd's Makefile:
openssl req -new -x509 -days 365 -nodes -out /tmp/foo.pem -keyout /tmp/foo.pem
and here you go:
https://localhost:4433/asterisk/manager
now works.
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@45869 f38db490-d61c-443f-a65b-d21fe96a405b
2006-10-22 12:02:35 +00:00
else {
ast_cli ( fd , " Server Enabled and Bound to %s:%d \n \n " ,
ast_inet_ntoa ( http_desc . oldsin . sin_addr ) ,
ntohs ( http_desc . oldsin . sin_port ) ) ;
if ( do_ssl )
ast_cli ( fd , " HTTPS Server Enabled and Bound to %s:%d \n \n " ,
ast_inet_ntoa ( https_desc . oldsin . sin_addr ) ,
ntohs ( https_desc . oldsin . sin_port ) ) ;
}
2006-03-25 23:50:09 +00:00
ast_cli ( fd , " Enabled URI's: \n " ) ;
urih = uris ;
while ( urih ) {
2006-04-02 09:10:43 +00:00
ast_cli ( fd , " %s/%s%s => %s \n " , prefix , urih - > uri , ( urih - > has_subtree ? " /... " : " " ) , urih - > description ) ;
2006-03-25 23:50:09 +00:00
urih = urih - > next ;
}
if ( ! uris )
ast_cli ( fd , " None. \n " ) ;
return RESULT_SUCCESS ;
}
int ast_http_reload ( void )
{
return __ast_http_load ( 1 ) ;
}
static char show_http_help [ ] =
2006-11-02 23:16:09 +00:00
" Usage: http show status \n "
2006-09-18 19:54:18 +00:00
" Lists status of internal HTTP engine \n " ;
static struct ast_cli_entry cli_http [ ] = {
2006-11-02 23:16:09 +00:00
{ { " http " , " show " , " status " , NULL } ,
2006-09-18 19:54:18 +00:00
handle_show_http , " Display HTTP server status " ,
2006-09-21 21:17:39 +00:00
show_http_help } ,
2006-03-25 23:50:09 +00:00
} ;
int ast_http_init ( void )
{
ast_http_uri_link ( & statusuri ) ;
2006-04-01 08:49:54 +00:00
ast_http_uri_link ( & staticuri ) ;
2006-09-18 19:54:18 +00:00
ast_cli_register_multiple ( cli_http , sizeof ( cli_http ) / sizeof ( struct ast_cli_entry ) ) ;
2006-03-25 23:50:09 +00:00
return __ast_http_load ( 0 ) ;
}