mod_musicindex.c

Go to the documentation of this file.

/*
 *  mod_musicindex.c
 *  mod_musicindex
 *
 *  $Id: mod_musicindex.c 1012 2012-08-08 08:58:25Z varenet $
 *
 *  Created by Regis BOUDIN on Sat Dec 28 2002.
 *  Copyright (c) 2002-2006 Regis BOUDIN
 *  Copyright (c) 2002-2005,2007-2008,2010-2012 Thibaut VARENE
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License version 2.1,
 *  as published by the Free Software Foundation.
 *
 */


#include "mod_musicindex.h"
#include "playlist.h"
#include "config.h"
#include "html.h"
#include "http.h"
#include "sort.h"

#include <http_core.h>

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_SETLOCALE
#include <locale.h>
#endif
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif

#ifdef BUILD_FOR_APACHE2

static const char *handlers[] = {
        "audio/mpeg",
        "audio/mp4",
        "audio/flac",
        "audio/ogg",
        "audio/x-flac",
        "application/x-flac",
        "application/ogg",
        "audio/x-ogg", /* At some point, we should be able to remove this one */
        NULL
};
#else
#include <http_main.h>
#endif

#ifdef ENABLE_OUTPUT_ARCHIVE
extern void send_tarball(request_rec *, const mu_pack *const);
extern ssize_t tarball_size(request_rec *, const mu_pack *const);
#endif

static int is_msie_user_agent(request_rec *r)
{
    const char* user_agent = NULL;

    user_agent = apr_table_get(r->headers_in, "User-Agent");
    return strstr(user_agent, "MSIE") && 1;
}

static int handle_musicindex(request_rec *r)
{
        /* Get the module configuration */
        mu_config *const conf = (mu_config *)ap_get_module_config(r->per_dir_config, &musicindex_module);
        mu_pack master_pack = {
                .head = NULL,
                .fhead = NULL,
                .dirnb = 0,
                .filenb = 0,
                .fsize = 0,
        },      custom_pack = {
                .head = NULL,
                .fhead = NULL,
                .dirnb = 0,
                .filenb = 0,
                .fsize = 0,
        };

        STRUCTTV tvbegin, tvprocess;
        
#ifdef HAVE_GETTIMEOFDAY
        struct timeval tvend;
        gettimeofday(&tvbegin, NULL);
#endif

        r->allowed |= ((1 << M_GET) | (1 << M_POST));

        /* if the the module is not active, decline the request */
        if (!(conf->options & MI_ACTIVE))
                return DECLINED;

#ifdef BUILD_FOR_APACHE2
        if(!r->handler || strcmp(r->handler, DIR_MAGIC_TYPE))
                return DECLINED;
#endif

        /* before doing anything (checking args, calling subfunctions), check we
           can open the directory */
        if (access(r->filename, R_OK|X_OK) != 0) {
                mi_rerror("Can't open directory: %s", r->filename);
                return HTTP_FORBIDDEN;
        }

        /* This part mostly comes from mod_autoindex. If the requested dir does
           not end with a '/', generate a new request with it */
        if (r->uri[0] == '\0' || r->uri[strlen(r->uri) - 1] != '/') {
                char *file;
                if (r->args != NULL)
                        file = apr_pstrcat(r->pool, ap_escape_uri(r->pool, r->uri),
                                                "/", "?", r->args, NULL);
                else
                        file = apr_pstrcat(r->pool, ap_escape_uri(r->pool, r->uri),
                                                "/", NULL);

                apr_table_setn(r->headers_out, "Location", ap_construct_url(r->pool, file, r));
                return HTTP_MOVED_PERMANENTLY;
        }

        /* Deal with optional arguments or decline requests we don't handle */
        switch (r->method_number) {
                case M_GET:
                        treat_get_args(r);
                        break;
                case M_POST:
                        treat_post_args(r);
                        break;
                default:
                        return DECLINED;
        }
        /* Now, the conf structure contains all the flags correctly set and
           conf->custom_list points to the arguments of the request, either given
           by get or post method */

        /* XXX this is ugly */
        if (conf->options & MI_RANDOMDIR) {
                conf->options &= ~MI_RANDOMDIR;
                send_randomdir(r);
                return HTTP_MOVED_TEMPORARILY;
        }

        /* Cache prologue can happen no later than here */
        if (conf->cache && conf->cache->prologue)
                conf->cache->prologue(r);

        /* build the string containing the cookie content. We need it for
           webpages and requests to stream the cookie content */
        if (((conf->options & (MI_STREAM|MI_TARBALL)) == 0) || ((conf->options & MI_STREAMRQ) == MI_STREAMCOOKIE) || ((conf->options & MI_DWNLDRQ) == MI_DWNLDCOOKIE))
                cookie_and_stream_work(r);

        if (((conf->options & MI_STREAMRQ) == MI_STREAMLST) ||
                ((conf->options & MI_STREAMRQ) == MI_COOKIESTREAM) ||
                ((conf->options & MI_DWNLDRQ) == MI_DWNLDLST) ||
                ((conf->options & MI_DWNLDRQ) == MI_COOKIEDWNLD)) {
                /* We build a custom playlist, don't bother with current directory */
                build_custom_list(r, &master_pack);
        }
        else {
                /* Build current directory content (recursive if necessary) */
                make_music_entry(r, r->pool, &master_pack, NULL, MI_RECURSIVE);
                listsort(&master_pack, conf->order);
        }

        /* Build custom link list, from conf->custom_list string */
        if (((conf->options & MI_STREAM) == 0) && (conf->custom_list != NULL))
                build_custom_list(r, &custom_pack);
        
        /* Cache epilogue can happen as early as here */
        if (conf->cache && conf->cache->epilogue)
                conf->cache->epilogue(r);

        /* Depending on the request type, set the HTTP headers. By default we
           return a web page. */
        if (conf->options & MI_STREAM) {
                char content_disposition[64] = "";
                        if (is_msie_user_agent(r))      /* this helps IE dealing with the data */
                                strcat(content_disposition, "attachment; ");

                strcat(content_disposition, "filename=\"playlist.m3u\"");

                ap_set_content_type(r, "audio/x-mpegurl");
                apr_table_set(r->headers_out, "Content-Disposition", content_disposition);
                /* apr_table_set() duplicates keys and values, this is necessary here */
        }
#ifdef ENABLE_OUTPUT_ARCHIVE
        else if (conf->options & MI_TARBALL) {
                const ssize_t tballsize = tarball_size(r, &master_pack);
                ap_set_content_type(r, "application/x-tar");
                apr_table_setn(r->headers_out, "Content-Disposition",
                        "filename = \"playlist.tar\"");
                /* send the size of the archive so that browsers can put a nice
                   progress bar
                   XXX correct modifier for size_t is 'z' but seems (some versions of?)
                   apache doesn't know about it. */
                apr_table_setn(r->headers_out, "Content-Length",
                        apr_psprintf(r->pool, "%lu", tballsize));
        }
#endif
        else if (conf->options & MI_RSS) {
                ap_set_content_type(r, "text/xml; charset=\"utf-8\"");
        }
        else {
                if (is_msie_user_agent(r))      /* IE derps on true XML */
                        ap_set_content_type(r, "text/html; charset=\"utf-8\"");
                else
                        ap_set_content_type(r, "application/xhtml+xml; charset=\"utf-8\"");

                /* If we have a cookie string, send it */
                if (conf->custom_list != NULL)
                        apr_table_setn(r->headers_out, "Set-Cookie", conf->custom_list);
        }

        ap_send_http_header(r);

        if (r->header_only)
                return OK;

#ifdef HAVE_GETTIMEOFDAY
        /* Timing request processing */
        gettimeofday(&tvend, NULL);
        timersub(&tvend, &tvbegin, &tvprocess);
#endif

        /* At this point we're sending data back */
        if (conf->options & MI_STREAM)
                send_playlist(r, &master_pack);
        else if (conf->options & MI_RSS)
                send_rss(r, &master_pack);
#ifdef ENABLE_OUTPUT_ARCHIVE
        else if (conf->options & MI_TARBALL)
                send_tarball(r, &master_pack);
#endif
        else {
                send_head(r);
                if (!conf->search && conf->dir_per_line)
                        send_directories(r, &master_pack);
                send_tracks(r, &master_pack);
                send_customlist(r, &custom_pack);
                send_foot(r, &tvbegin, &tvprocess);
        }

        return OK;
}

static int handle_musicfile(request_rec *r)
{
        mu_config *const conf = (mu_config *)ap_get_module_config(r->per_dir_config, &musicindex_module);

#ifdef BUILD_FOR_APACHE2
        register unsigned short i;
#endif

        /* is this a request method we handle? */
        if ((r->method_number != M_GET) || (!(conf->options & MI_ACTIVE)))
                return DECLINED;

#ifdef BUILD_FOR_APACHE2
        /* is this a mime type we handle? */
        if (!r->handler)
                return DECLINED;
        
        for (i=0; handlers[i] && strcmp(r->handler, handlers[i]); i++);

        if (handlers[i] == NULL)
                return DECLINED;
#endif

        /* request response rationale:
           - Stream is allowed:
                + we have a "?stream" argument in the request, the client asks for
                  a playlist containing a single file -> OK
                + we have no argument and no icecast server is set -> set Content-Length
                  and DECLINED
           - Download is allowed:
                + we have no argument -> DECLINED
           Otherwise, we consider it is a forbidden request. Keep in mind that
           DECLINED just means the module won't handle the request, whereas
           HTTP_FORBIDDEN means the request is not allowed, no matter what. */

        if (conf->options & MI_ALLOWSTREAM) {
                mu_pack master_pack = {
                        .head = NULL,
                        .fhead = NULL,
                        .dirnb = 0,
                        .filenb = 0,
                };

                if (r->args && !strcmp(r->args, "stream")) {
                        ap_set_content_type(r, "audio/x-mpegurl");
                        apr_table_setn(r->headers_out, "Content-Disposition",
                                "filename = \"playlist.m3u\"");

                        ap_send_http_header(r);

                        if (r->header_only)
                                return OK;
                }                       

                if (conf->cache && conf->cache->prologue)
                        conf->cache->prologue(r);

                make_music_entry(r, r->pool, &master_pack, NULL, MI_ALLOWSTREAM);

                if (conf->cache && conf->cache->epilogue)
                        conf->cache->epilogue(r);

                master_pack.fhead = master_pack.head;
                
                /* the request is trying to fetch a file - STREAM allowed so we go the extra mile */
                if (!r->args && !conf->iceserver) {
                        /* RFC 3803 */
                        apr_table_setn(r->headers_out, "Content-Duration", 
                                apr_psprintf(r->pool, "%hu", master_pack.fhead->length));

                        return DECLINED; /* let Apache deal with the actual file */
                }
                
                if (r->args && !strcmp(r->args, "stream")) {
                        send_playlist(r, &master_pack);

                        return OK;
                }
        }

        /* trying to fetch a file, STREAM disabled, let's see if DWNLD is allowed */
        if ((!r->args) && (conf->options & MI_ALLOWDWNLD))
                return DECLINED;

        /* all else failing, we deny the request */
        return HTTP_FORBIDDEN;
}

#ifndef BUILD_FOR_APACHE2 /* we build for apache 1.3 */

static void musicindex_init(server_rec *s, apr_pool_t *p)
{
#ifdef HAVE_GETTEXT
#ifdef HAVE_SETLOCALE
        setlocale(LC_ALL, "");
#endif
        textdomain("mod_musicindex");
        bind_textdomain_codeset("mod_musicindex","UTF-8");      /* forcons la raie */
#endif

        ap_add_version_component(MUSIC_HEADER_STRING);
}

/* XXX Shit, that sucks hell, that's another place to edit when adding/removing a handler DAMN! */
static const handler_rec musicindex_handlers[] = {
        {DIR_MAGIC_TYPE, handle_musicindex},
        {"audio/mpeg", handle_musicfile},
        {"audio/ogg", handle_musicfile},
        {"audio/x-ogg", handle_musicfile}, /* Backward compatibility */
        {"application/ogg", handle_musicfile},
        {"audio/flac", handle_musicfile},
        {"audio/x-flac", handle_musicfile},
        {"application/x-flac", handle_musicfile},
        {"audio/mp4", handle_musicfile},        /* XXX cette struct sert a quoi exactement? MP4 marchait meme sans ca */
        {NULL}
};

/* XXX init happens after configuration, it should be possible to hook cache init there */
module MODULE_VAR_EXPORT musicindex_module = {
        STANDARD_MODULE_STUFF,
        musicindex_init,                
        create_musicindex_config,       
        merge_musicindex_configs,       
        NULL,                           
        NULL,                           
        musicindex_cmds,                
        musicindex_handlers,            
        NULL,                           
        NULL,                           
        NULL,                           
        NULL,                           
        NULL,                           
        NULL,                           
        NULL,                           
        NULL,                           
        NULL,                           
        NULL,                           
        NULL                            
};

#else /* we build for apache 2 */

static int musicindex_init(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
{
#ifdef HAVE_GETTEXT
#ifdef HAVE_SETLOCALE
        setlocale(LC_ALL, "");
#endif
        textdomain("mod_musicindex");
        bind_textdomain_codeset("mod_musicindex","UTF-8");      /* forcons la raie */
#endif

        ap_add_version_component(p, MUSIC_HEADER_STRING);

        return OK;
}

static void register_hooks(apr_pool_t *p)
{
        /* for directories, set the mod_autoindex to be called after us */
        /* This should not be necessary with V2.0 */
        static const char * const after[] = { "mod_autoindex.c", NULL };
        ap_hook_handler(handle_musicindex, NULL, after, APR_HOOK_MIDDLE);
        ap_hook_handler(handle_musicfile, NULL, NULL, APR_HOOK_MIDDLE);
        ap_hook_post_config(musicindex_init, NULL, NULL, APR_HOOK_LAST);
}

module AP_MODULE_DECLARE_DATA musicindex_module = {
    STANDARD20_MODULE_STUFF,
    create_musicindex_config,   /* create per-directory config structure */
    merge_musicindex_configs,   /* merge per-directory config structures */
    NULL,                       /* create per-server config structure */
    NULL,                       /* merge per-server config structures */
    musicindex_cmds,            /* command apr_table_t */
    register_hooks              /* register hooks */
};

#endif /* BUILD_FOR_APACHE2 */