mod_webkeep.c #6

/*
 * Copyright 1995, 1998 Perforce Software.  
 *
 * This file is part of WebKeeper, a perforce client apache module.
 *
 * License is hereby granted to use this software and distribute it
 * freely, as long as this copyright notice is retained and modifications
 * are clearly marked.
 *
 * ALL WARRANTIES ARE HEREBY DISCLAIMED.
 *
 * $Id: //guest/raymond_wiker/webkeeper/mod_webkeep.c#6 $
 */

/*
 * mod_webkeep.c: the apache side glue (in C) to the Perforce client
 *
 * This module by Perforce Software, from a template by the Apache Group.
 */

#include "httpd.h"
#include "http_config.h"
#include "mod_webkeep.h"

typedef struct {
    char *real;
    char *fake;
} alias_entry;

typedef struct {

    array_header *aliases;
    WebKeepConnect p4;

} alias_server_conf;

typedef struct {
    char *filename;
    int revision;
    char *filetype;
} file_dir_info;

module webkeep_module;

static
void *create_webkeep_config (pool *p, server_rec *s)
{
    alias_server_conf *a;

    a = (alias_server_conf *)ap_pcalloc (p, sizeof(alias_server_conf));
    a->aliases = ap_make_array (p, 20, sizeof(alias_entry));
    a->p4.port = 0;
    a->p4.user = 0;
    a->p4.pass = 0;
    a->p4.client = 0;
    a->p4.indexname = 0;

    return a;
}

static
void *merge_webkeep_config (pool *p, void *basev, void *overridesv)
{
    alias_server_conf *a, *b, *o;

    a = (alias_server_conf *)ap_pcalloc (p, sizeof(alias_server_conf));
    b = (alias_server_conf *)basev;
    o = (alias_server_conf *)overridesv;

    a->aliases = ap_append_arrays (p, o->aliases, b->aliases);

    a->p4.port = o->p4.port ? o->p4.port : b->p4.port;
    a->p4.user = o->p4.user ? o->p4.user : b->p4.user;
    a->p4.pass = o->p4.pass ? o->p4.pass : b->p4.pass;
    a->p4.client = o->p4.client ? o->p4.client : b->p4.client;
    a->p4.indexname = o->p4.indexname ? o->p4.indexname :
	b->p4.indexname; 

    return a;
}

static
const char *add_webkeep(cmd_parms *cmd, void *dummy, char *f, char *r)
{
    server_rec *s = cmd->server;
    alias_server_conf *conf;
    alias_entry *new;

    conf = (alias_server_conf *)
	ap_get_module_config(s->module_config,&webkeep_module);

    new = ap_push_array (conf->aliases);

    /* XX r can NOT be relative to DocumentRoot here... compat bug. */
    
    new->fake = f;
    new->real = r; 

    return NULL;
}

static
const char *port_webkeep(cmd_parms *cmd, void *d, char *f)
{
    server_rec *s = cmd->server;
    alias_server_conf *conf;

    conf = (alias_server_conf *)
	ap_get_module_config(s->module_config,&webkeep_module);

    conf->p4.port = f;

    return NULL;
}

static
const char *user_webkeep(cmd_parms *cmd, void *d, char *f)
{
    server_rec *s = cmd->server;

    alias_server_conf *conf;

    conf = (alias_server_conf *)
	ap_get_module_config(s->module_config,&webkeep_module);

    conf->p4.user = f;

    return NULL;
}

static
const char *passwd_webkeep(cmd_parms *cmd, void *d, char *f)
{
    server_rec *s = cmd->server;
    alias_server_conf *conf;

    conf = (alias_server_conf *)
	ap_get_module_config(s->module_config,&webkeep_module);

    conf->p4.pass = f;

    return NULL;
}

static
const char *client_webkeep(cmd_parms *cmd, void *d, char *f)
{
    server_rec *s = cmd->server;
    alias_server_conf *conf;

    conf = (alias_server_conf *)
	ap_get_module_config(s->module_config,&webkeep_module);

    conf->p4.client = f;

    return NULL;
}

static
const char *index_webkeep(cmd_parms *cmd, void *d, char *f)
{
    server_rec *s = cmd->server;
    alias_server_conf *conf;

    conf = (alias_server_conf *)
	ap_get_module_config(s->module_config,&webkeep_module);

    conf->p4.indexname = f;

    return NULL;
}

static
command_rec alias_cmds[] = {
    { "WebKeepAlias", add_webkeep, NULL, RSRC_CONF, TAKE2, 
      "a fakename and a depot name"},
    { "WebKeepPort", port_webkeep, NULL, RSRC_CONF, TAKE1, 
      "a TCP/IP host:port"},
    { "WebKeepUser", user_webkeep, NULL, RSRC_CONF, TAKE1, 
      "a Perforce user name"},
    { "WebKeepPasswd", passwd_webkeep, NULL, RSRC_CONF, TAKE1, 
      "a Perforce user password"},
    { "WebKeepClient", client_webkeep, NULL, RSRC_CONF, TAKE1, 
      "a Perforce client name"},
    { "WebKeepIndex", index_webkeep, NULL, RSRC_CONF, TAKE1, 
      "File name to use for a default index"},
    { NULL }
};

static
int alias_matches (char *uri, char *alias_fakename)
{
    char *end_fakename = alias_fakename + strlen (alias_fakename);
    char *aliasp = alias_fakename, *urip = uri;

    while (aliasp < end_fakename) {
	if (*aliasp == '/') {
	    /* any number of '/' in the alias matches any number in
	     * the supplied URI, but there must be at least one...
	     */
	    if (*urip != '/') return 0;
	    
	    while (*aliasp == '/') ++ aliasp;
	    while (*urip == '/') ++ urip;
	}
	else if ( aliasp == end_fakename - 1 && *aliasp == '$') {
	    /* a $ at the end of the fakename means it must match
	     * the IRI exactly: i.e. no initial substring match.
	     */
	    if (*urip != 0) return 0;
	    ++ aliasp;
	}
	else {
	    /* Other characters are compared literally */
	    if (*urip++ != *aliasp++) return 0;
	}
    }

    /* Check last alias path component matched all the way */

    if (aliasp[-1] != '/' && *urip != '\0' && *urip != '/')
	return 0;

    /* Return number of characters from URI which matched (may be
     * greater than length of alias, since we may have matched
     * doubled slashes)
     */

    return urip - uri;
}

static
int translate_webkeep(request_rec *r)
{
    int i;
    void *sconf;
    alias_server_conf *conf;
    alias_entry *entries;

    if (r->uri[0] != '/' && r->uri[0] != '\0') 
        return BAD_REQUEST;

    sconf = r->server->module_config;
    conf = (alias_server_conf *)ap_get_module_config(sconf, &webkeep_module);
    entries = (alias_entry *)conf->aliases->elts;
    
    for (i = 0; i < conf->aliases->nelts; ++i) {
        alias_entry *p = &entries[i];
        int l = alias_matches (r->uri, p->fake);

        if (l > 0) 
	{
	    /*
	     * We stash this under webkeep-path, instead of r->filename,
	     * because (a) we have to communicate to our handle_webkeep
	     * that this is one of ours and (b) because filename gets
	     * mangled by the access checking code.  There must be a
	     * way around this, but it is buried in the minds of the 
	     * apache writers.
	     */

	    ap_table_set( r->notes, "webkeep-path", 
			  ap_pstrcat(r->pool, p->real, r->uri + l, NULL) );
	    return OK;
	}
    }

    return DECLINED;
}

void parsefileinfo(request_rec *r, const char *info,
		   char **fname, char **rev, char **action, 
		   char **chgnum, char **filetype)
{
    const char *q;		/* sigh... */
    char *p;
    char *buf;

    /* filename follows last '/'. Allow for the (possible?) case that
     * there is no path */
    q = strrchr(info, '/');
    q = q ? q + 1 : info;

    /* allocate buffer to hold a copy of the entire info string, from
     * the beginning of the filename and onwards. the pointer-pointers 
     * passed as parameters are set to point into the copy of the
     * string, with ascii-nulls inserted to delimit parameters in the
     * string. */
    buf = ap_pstrcat(r->pool, q, 0);
    ap_assert(buf != 0);

    /* Ok - filename up until '#' ... */
    *fname = buf;
    p = strchr(*fname, '#');
    ap_assert(p != 0);
    *p = 0;

    /* Then file revision up until the first blank (space) */
    *rev = p + 1;
    p = strchr(*rev, ' ');
    ap_assert(p != 0);
    *p = 0;
    /* skip following "- "... */
    ap_assert(*++p == '-');
    ap_assert(*++p == ' ');

    /* action up until next blank */
    *action = p + 1;
    p = strchr(*action, ' ');
    ap_assert(p != 0);
    *p = 0;

    /* filetype in brackets - find opening bracket */
    p = strchr(p + 1, '(');
    ap_assert(p != 0);
    *filetype = p + 1;
    p = strchr(*filetype, ')');
    ap_assert(p != 0);
    *p = 0;
}

static void appendfile(WebKeepPrinter *printer, const char *info)
{
    file_dir_info *new;
    char *fname, *rev, *action, *chgnum, *ftype;
    
    request_rec *r = (request_rec *)printer->closure;

    parsefileinfo(r, info, &fname, &rev, &action, &chgnum,
		  &ftype); 

    if (strcmp(action, "delete") == 0) {
	return;
    }

    /* else */
    if (printer->files == 0) 
    {
	printer->files = ap_make_array(r->pool, 10,
				       sizeof(file_dir_info));
	ap_assert(printer->files != 0);
    }

    new = (file_dir_info *) ap_push_array((array_header *)
					  printer->files); 
    ap_assert(new != 0);

    new->filename = fname;
    new->revision = atoi(rev);
    new->filetype = ftype;
}

static void appenddir(WebKeepPrinter *printer, const char *info)
{
    char **new;
    char *p;
    const char *q;
    request_rec *r = (request_rec *)printer->closure;
    
    if (printer->dirs == 0) 
    {
	printer->dirs = ap_make_array(r->pool, 10,
				      sizeof(char *));
	ap_assert(printer->dirs != 0);
    }
    new = (char **) ap_push_array(printer->dirs);
    ap_assert(new != 0);

    /* find last path separator, if any */
    /* assume that there is no trailing path separator */

    q = strrchr(info, '/');
    q = q ? q + 1 : info;
    *new = ap_pstrcat(r->pool, q, 0);
    ap_assert(*new != 0);
}

/* Webkeeper glue */

/* Protocol:
 * 
 * webKeepData() is called every time something is sent through the
 * OutputInfo() method. webKeepData() examines the WebKeepPrinter
 * structure, and does one of the following:
 * 1) If we're currently creating a "directory listing": analyse the
 * information we were passed, and append file or directory data to
 * the WebKeepPrinter structure.
 * 2) If we're printing a file: analyse the information passed, and
 * set the content-type element in the WebKeepPrinter structure
 * accordingly.
 *
 * webKeepError() is called whenever something is sent through the
 * OutputError() method. webKeepError() examines the WebKeepPrinter
 * structure, increments the error count in the WebKeepPrinter structure
 * and logs an error (unless a flag in the WebKeepPrinter structure
 * tells it to be quiet).
 *
 * webKeepText() is called to output data from the Perforce
 * API.
 *
 * webKeepDir() is called to dump out a directory structure.
 * 
 */

void
webKeepData( WebKeepPrinter *printer, const char *info )
{
    request_rec *r = (request_rec *)printer->closure;

    if (printer->collectinfo) 
    {				/* directory building */
	if (strchr(info, '#') != 0) 
	{			/* file element */
	    appendfile(printer, info);
	}
	else {
	    appenddir(printer, info);
	}
    }
    else if (printer->print)
    {				/* printing file */
	if (strlen(info) > 5 &&
	    strcmp(info + strlen(info) - 5, "text)") != 0) 
	{
	    r->content_type = "application/octet-stream";
	}

	ap_send_http_header( r );
    }
}

void
webKeepError( WebKeepPrinter *printer, char *buf )
{
    printer->errorcount++;

    if (! printer->ignoreerrors) 
    {
	request_rec *r = (request_rec *)printer->closure;
	ap_log_reason(buf, r->uri, r);
    }
}

void
webKeepText( WebKeepPrinter *printer, char *buf, int len )
{
    request_rec *r = (request_rec *)printer->closure;

    while( len-- )
	ap_rputc( *buf++, r );
}

const char *iconbytype(const char *type)
{
    static const char* lookup[] =
    {
	"dir", "folder.gif",	/* non-perforce file type */
	"text", "text.gif",
	"ktext", "text.gif",
	"binary", "binary.gif",
	0, 0
    };
    const char **p;
    for (p = lookup; *p; p += 2) 
    {
	if (strcmp(*p, type) == 0) 
	{
	    return *(p + 1);
	}
    }
    /* else */
    return "unknown.gif";
}

void embedimagebytype(request_rec *r, const char *type)
{
    ap_rprintf(r, "%s", "<img src=\"/icons/");
    ap_rprintf(r, "%s", iconbytype(type));
    ap_rprintf(r, "%s", "\">");
}

void webKeepDir(WebKeepPrinter *printer)
{
    request_rec *r = printer->closure;
    int i;
    char **cpp;
    file_dir_info *fdip;

    r->content_type = "text/html";

    ap_send_http_header(r);

    ap_rprintf(r, "<html><head>\n");
    ap_rprintf(r, "<title>Directory Output</title>\n");
    ap_rprintf(r, "</head>\n");
    ap_rprintf(r, "<body>\n");
    ap_rprintf(r, "<h2>Contents of %s:</h2><br>\n", r->uri);
    embedimagebytype(r, "dir");
    ap_rprintf(r, "<a href=\"../\">Parent directory</a><br>\n");
    if (printer->dirs != 0) 
    {
	for (i = 0, 
		 cpp = (char **) ((array_header *) printer->dirs)->elts;
	     i < ((array_header *) printer->dirs)->nelts;
	     cpp++, i++) 
	{
	    embedimagebytype(r, "dir");
	    ap_rprintf(r, "<a href=\"%s/\">%s</a><br>\n",
		       *cpp, *cpp);
	}
    }
    if (printer->files != 0)
    {
	for (i = 0, 
		 fdip = (file_dir_info *)
		 ((array_header *) printer->files)->elts; 
	     i < ((array_header *) printer->files)->nelts; 
	     i++, fdip++)
	{
	    embedimagebytype(r, fdip->filetype);
	    ap_rprintf(r, "<a href=\"%s\">%s#%d</a>(%s)<br>\n",
		       fdip->filename, 
		       fdip->filename, fdip->revision,
		       fdip->filetype);
	}
    }
    ap_rprintf(r, "</body></html>\n");
}

/* The formal handler... */

static
int handle_webkeep (request_rec *r)
{
    void *sconf;
    alias_server_conf *conf;
    WebKeepPrinter printer;
    const char *depotPath;

    /* For us? */

    if (r->method_number != M_GET) return DECLINED;

    if (!(depotPath = ap_table_get(r->notes, "webkeep-path")))
    {
	return DECLINED;
    }

    /* The mulberry bush. */

    sconf = r->server->module_config;
    conf = (alias_server_conf *)ap_get_module_config(sconf, &webkeep_module);

    printer.closure = (void *)r;
    printer.data = webKeepData;
    printer.text = webKeepText;
    printer.error = webKeepError;
    printer.dir = webKeepDir;

    printer.dirs = printer.files = 0;

    return webKeepPrint( &conf->p4, depotPath, &printer ) != 0 ?
	OK : NOT_FOUND;
}


handler_rec webkeep_handlers[] = {
    { "*/*", handle_webkeep },
    { NULL }
};

module webkeep_module = {
   STANDARD_MODULE_STUFF,
   NULL,			/* initializer */
   NULL,			/* dir config creater */
   NULL,			/* dir merger --- default is to override */
   create_webkeep_config,	/* server config */
   merge_webkeep_config,	/* merge server configs */
   alias_cmds,			/* command table */
   webkeep_handlers,		/* handlers */
   translate_webkeep,		/* filename translation */
   NULL,			/* check_user_id */
   NULL,			/* check auth */
   NULL,			/* check access */
   NULL,			/* type_checker */
   NULL,			/* fixups */
   NULL				/* logger */
};