/*	$NetBSD: uri.c,v 1.4 2026/07/09 16:54:11 mlelstv Exp $	*/

/*-
 * Copyright (c) 2026 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "ssl.h"
#include "ftp_var.h"
#include "uri.h"

typedef struct {
	const char *buf;
	size_t scheme;
	size_t authority;
	size_t path;
	size_t query;
	size_t fragment;
} uriparts_t;

#define SCHEME(p) ((p)->buf)
#define AUTHORITY(p) (SCHEME(p) + (p)->scheme)
#define PATH(p) (AUTHORITY(p) + (p)->authority)
#define QUERY(p) (PATH(p) + (p)->path)
#define FRAGMENT(p) (QUERY(p) + (p)->query)

static void
split_uri(const char *uri, uriparts_t *parts)
{
	char *colon, *slash, *query, *sharp;

	parts->buf = uri;
	parts->scheme = 0;
	parts->authority = 0;
	parts->path = 0;
	parts->query = 0;
	parts->fragment = 0;

	colon = strchr(uri, ':');
	slash = strchr(uri, '/');
	if (colon && (slash == NULL || (colon - uri) < (slash - uri))) {
		parts->scheme = colon + 1 - uri;
		uri = colon + 1;
	}       

	if (uri[0] == '/' && uri[1] == '/') {
		slash = strchr(uri + 2, '/');
		if (slash == NULL) {
			parts->authority = strlen(uri); 
			return;
		}
		parts->authority = slash - uri;
		uri = slash;
	}       

	query = strchr(uri, '?');
	sharp = strchr(uri, '#');
	if (query && (sharp == NULL || (query - uri) < (sharp - uri))) {
		parts->path = query - uri;
		uri = query;
		if (sharp != NULL) {
			parts->query = sharp - query;
			parts->fragment = strlen(sharp);
			return;
		}
		parts->query = strlen(query);
		return;
	}

	if (sharp != NULL) {
		parts->path = sharp - uri;
		parts->fragment = strlen(sharp);
		return;
	}

	parts->path = strlen(uri);
}

static char *
build_uri(uriparts_t *s, uriparts_t *a, uriparts_t *p,
    uriparts_t *q, uriparts_t *f)
{
	size_t len;
	char *buf, *out;

	len = s->scheme + a->authority + p->path + q->query + f->fragment;
	buf = ftp_malloc(len + 1);

	out = buf;
	memcpy(out, SCHEME(s), s->scheme);
	out += s->scheme;
	memcpy(out, AUTHORITY(a), a->authority);
	out += a->authority;
	memcpy(out, PATH(p), p->path);
	out += p->path;
	memcpy(out, QUERY(q), q->query);
	out += q->query;
	memcpy(out, FRAGMENT(f), f->fragment);
	out += f->fragment;
	*out = '\0';

	return buf;
}

static char *
remove_dot_segments(const char *path, size_t len)
{
	char *p;
	char *pbuf, *buf, *out, *seg;
	size_t n;

	p = pbuf = ftp_malloc(len + 1);
	memcpy(p, path, len);
	p[len] = '\0';

	buf = ftp_malloc(len + 1);
	out = buf;
	*out = '\0';

	while (len > 0) {
		/* A */
		if (p[0] == '.') {
			if (len > 1 && p[1] == '/') {
				p += 2;
				len -= 2;
				continue;
			} else if (len > 2 && p[1] == '.' && p[2] == '/') {
				p += 3;
				len -= 3;
				continue;
			}
		}

		/* B */
		if (p[0] == '/') {
			if (len > 2 && p[1] == '.' && p[2] == '/') {
				p += 2;
				len -= 2;
				continue;
			} else if (len == 2 && p[1] == '.') {
				p += 1;
				len -= 1;
				p[0] = '/';
				continue;
			}
		}

		/* C */
		if (len > 2 && p[0] == '/' && p[1] == '.' && p[2] == '.') {
			if (len > 3 && p[3] == '/') {
				p += 3;
				len -= 3;
				seg = strrchr(buf, '/');
				if (seg != NULL)
					*seg = '\0';
				continue;
			} else if (len == 3) {
				p += 2;
				len -= 2;
				p[0] = '/';
				seg = strrchr(buf, '/');
				if (seg != NULL)
					*seg = '\0';
				continue;
			}
		}

		/* D */
		if (p[0] == '.') {
			if (len == 1) {
				p += 1;
				len -= 1;
				continue;
			} else if (len == 2 && p[1] == '.') {
				p += 2;
				len -= 2;
				continue;
			}
		}

		/* E */
		if (p[0] == '/') {
			seg = strchr(p+1, '/');
		} else {
			seg = strchr(p, '/');
		}
		if (seg != NULL) {
			n = seg - p;
			if (n > len)
				n = len;
		} else
			n = len;

		memcpy(out, p, n);
		out += n;
		*out = '\0';
		p += n;
		len -= n;
	};

	FREEPTR(pbuf);

	return buf;
}

static char *
merge_paths(uriparts_t *base, uriparts_t *ref)
{
	char *buf;
	const char *path, *last;
	size_t len;

	if (base->authority && base->path == 0) {
		len = 1 + ref->path;
		buf = ftp_malloc(len + 1);
		buf[0] = '/';
		memcpy(buf + 1, PATH(ref), ref->path);
	} else {
		path = PATH(base);
		last = strrchr(path, '/');
		if (last == NULL || (size_t)(last - path) > base->path)
			len = 0;
		else
			len = (size_t)(last - path) + 1;
		buf = ftp_malloc(len + ref->path + 1);
		memcpy(buf, path, len);
		memcpy(buf + len, PATH(ref), ref->path);
		len += ref->path;
	}
	buf[len] = '\0';

	return buf;
}

char *
make_absurl(char *refurl, const char *baseurl)
{
	uriparts_t base;
	uriparts_t ref;
	uriparts_t p;
	char *buf, *tmp1, *tmp2;

	split_uri(baseurl, &base);
	split_uri(refurl, &ref);

	p.scheme = p.authority = p.path = p.query = p.fragment = 0;

	if (ref.scheme) {
		tmp1 = remove_dot_segments(PATH(&ref), ref.path);
		p.buf = tmp1;
		p.path = strlen(tmp1);
		buf = build_uri(&ref, &ref, &p, &ref, &ref);
		FREEPTR(tmp1);
	} else {
		if (ref.authority) {
			tmp1 = remove_dot_segments(PATH(&ref), ref.path);
			p.buf = tmp1;
			p.path = strlen(tmp1);
			buf = build_uri(&base, &ref, &p, &ref, &ref);
			FREEPTR(tmp1);
		} else {
			if (ref.path == 0) {
				if (ref.query) {
					buf = build_uri(&base, &base, &base, &ref, &ref);
				} else {
					buf = build_uri(&base, &base, &base, &base, &ref);
				}
			} else {
				if (PATH(&ref)[0] == '/') {
					tmp1 = remove_dot_segments(PATH(&ref), ref.path);
					p.buf = tmp1;
					p.path = strlen(tmp1);
					buf = build_uri(&base, &base, &p, &ref, &ref);
					FREEPTR(tmp1);
				} else {
					tmp2 = merge_paths(&base, &ref);
					tmp1 = remove_dot_segments(tmp2, strlen(tmp2));
					p.buf = tmp1;
					p.path = strlen(tmp1);
					FREEPTR(tmp2);

					buf = build_uri(&base, &base, &p, &ref, &ref);
					FREEPTR(tmp1);
				}
			}
		}
	}

	FREEPTR(refurl);

	return buf;
}