path: root/camel/camel-url.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* camel-url.c : utility functions to parse URLs */


/* 
 * Authors:
 *  Bertrand Guiheneuf <bertrand@helixcode.com>
 *  Dan Winship <danw@helixcode.com>
 *
 * Copyright 1999, 2000 Helix Code, Inc. (http://www.helixcode.com)
 *
 * This program is free software; you can redistribute it and/or 
 * modify it under the terms of the GNU General Public License as 
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 */



/* XXX TODO:
 * recover the words between #'s or ?'s after the path
 * % escapes
 */

#include <config.h>
#include <stdlib.h>
#include <string.h>
#include "camel-url.h"
#include "camel-exception.h"

/**
 * camel_url_new: create a CamelURL object from a string
 * @url_string: The string containing the URL to scan
 * 
 * This routine takes a string and parses it as a URL of the form:
 *
 *   protocol://user;AUTH=mech:password@host:port/path
 *
 * The protocol, followed by a ":" is required. If it is followed by
 * "//", there must be an "authority" containing at least a host,
 * which ends at the end of the string or at the next "/". If there
 * is an "@" in the authority, there must be a username before it,
 * and the host comes after it. The authmech, password, and port are
 * optional, and the punctuation that preceeds them is omitted if
 * they are. Everything after the authority (or everything after the
 * protocol if there was no authority) is the path. We consider the
 * "/" between the authority and the path to be part of the path,
 * although this is incorrect according to RFC 1738.
 *
 * The port, if present, must be numeric.
 * 
 * Return value: a CamelURL structure containing the URL items.
 **/
CamelURL *
camel_url_new (const char *url_string, CamelException *ex)
{
    CamelURL *url;
    char *semi, *colon, *at, *slash;

    /* Find protocol: initial substring until ":" */
    colon = strchr (url_string, ':');
    if (!colon) {
        camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_URL_INVALID,
                      "URL string `%s' contains no protocol",
                      url_string);
        return NULL;
    }

    url = g_new0 (CamelURL, 1);
    url->protocol = g_strndup (url_string, colon - url_string);

    if (strncmp (colon, "://", 3) != 0) {
        if (*(colon + 1))
            url->path = g_strdup (colon + 1);
        return url;
    }

    url_string = colon + 3;

    /* If there is an @ sign in the authority, look for user,
     * authmech, and password before it.
     */
    slash = strchr (url_string, '/');
    at = strchr (url_string, '@');
    if (at && (!slash || at < slash)) {
        colon = strchr (url_string, ':');
        if (colon && colon < at)
            url->passwd = g_strndup (colon + 1, at - colon - 1);
        else {
            url->passwd = NULL;
            colon = at;
        }

        semi = strchr(url_string, ';');
        if (semi && (semi < colon || (!colon && semi < at)) &&
            !strncasecmp (semi, ";auth=", 6)) {
            url->authmech = g_strndup (semi + 6,
                             colon - semi - 6);
        } else {
            url->authmech = NULL;
            semi = colon;
        }

        url->user = g_strndup (url_string, semi - url_string);
        url_string = at + 1;
    } else
        url->user = url->passwd = url->authmech = NULL;

    /* Find host and port. */
    slash = strchr (url_string, '/');
    colon = strchr (url_string, ':');
    if (slash && colon > slash)
        colon = NULL;

    if (colon) {
        url->host = g_strndup (url_string, colon - url_string);
        url->port = strtoul (colon + 1, &colon, 10);
        if (*colon && colon != slash) {
            camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_URL_INVALID,
                          "Port number in URL `%s' is non-"
                          "numeric", url_string);
            camel_url_free (url);
            return NULL;
        }
    } else if (slash) {
        url->host = g_strndup (url_string, slash - url_string);
        url->port = 0;
    } else {
        url->host = g_strdup (url_string);
        url->port = 0;
    }

    if (!slash)
        slash = "/";
    url->path = g_strdup (slash);

    return url;
}

char *
camel_url_to_string (CamelURL *url, gboolean show_passwd)
{
    char port[20];

    if (url->port)
        g_snprintf (port, sizeof (port), "%d", url->port);
    else
        *port = '\0';

    return g_strdup_printf ("%s:%s%s%s%s%s%s%s%s%s%s%s",
                url->protocol,
                url->host ? "//" : "",
                url->user ? url->user : "",
                url->authmech ? ";auth=" : "",
                url->authmech ? url->authmech : "",
                url->passwd && show_passwd ? ":" : "",
                url->passwd && show_passwd ? url->passwd : "",
                url->user ? "@" : "",
                url->host ? url->host : "",
                url->port ? ":" : "",
                port,
                url->path ? url->path : "");
}

void
camel_url_free (CamelURL *url)
{
    g_assert (url);

    g_free (url->protocol);
    g_free (url->user);
    g_free (url->authmech);
    g_free (url->passwd);
    g_free (url->host);
    g_free (url->path);

    g_free (url);
}