wdvi

util.c (8336B)

---

 /*========================================================================*\
 
 Copyright (c) 1990-2013  Paul Vojta
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to
 deal in the Software without restriction, including without limitation the
 rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 sell copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 PAUL VOJTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 NOTE:
 	xdvi is based on prior work, as noted in the modification history
 	in xdvi.c.
 
 \*========================================================================*/
 
 #include <err.h>
 #include <fcntl.h>	/* fcntl() */
 #include <stdlib.h>	/* malloc(), realloc() */
 #include <string.h>	/* strdup(), memcpy() */
 #include <strings.h>	/* bcopy() */
 #include <pwd.h>	/* getpwuid(), getpwnam() */
 #include <unistd.h>	/* getuid() */
 
 #include "util.h"
 #include "xdvi.h"
 
 
 /*
  *	General utility routines.
  */
 
 /*
  *	Either (re)allocate storage or fail with explanation.
  */
 void *
 xmalloc(size_t size)
 {
 	void	*mem	= malloc(size);
 
 	if (mem == NULL)
 	    err(1, "malloc %zu bytes", size);
 	return mem;
 }
 
 void *
 xrealloc(void *where, size_t size)
 {
 	void	*mem	= realloc(where, size);
 
 	if (mem == NULL)
 	    err(1, "realloc %zu bytes", size);
 	return mem;
 }
 
 /*
  *	Allocate a new string.
  */
 char *
 xstrdup(const char *str)
 {
 	char	*new;
 
 	if ((new = strdup(str)) == NULL)
 		err(1, "strdup");
 	return new;
 }
 
 /*
  *	Allocate a new string.  The second argument is the length.
  */
 char *
 xmemdup(const char *str, size_t len)
 {
 	char	*new;
 
 	new = xmalloc(len);
 	memcpy(new, str, len);
 	return new;
 }
 
 /*
  *	Expand the matrix *ffline to at least the given size.
  */
 void
 expandline(size_t n)
 {
 	size_t	newlen	= n + 128;
 
 	ffline = (ffline == NULL) ? xmalloc(newlen) : xrealloc(ffline, newlen);
 	ffline_len = newlen;
 }
 
 /*
  *	Allocate bitmap for given font and character
  */
 void
 alloc_bitmap(struct bitmap *bitmap)
 {
 	unsigned int	size;
 
 	/* width must be multiple of 16 bits for raster_op */
 	bitmap->bytes_wide = ROUNDUP((int) bitmap->w, BMBITS) * BMBYTES;
 	size = bitmap->bytes_wide * bitmap->h;
 	bitmap->bits = xmalloc(size != 0 ? size : 1);
 }
 
 /*
  *	Open a file in the given mode.
  */
 FILE *
 xfopen(const char *filename, const char *type)
 {
 	FILE	*f;
 
 	f = fopen(filename, type);
 
 	if (f != NULL)
 	    (void) fcntl(fileno(f), F_SETFD, 1);
 
 	return f;
 }
 
 /*
  *	Perform tilde expansion, updating the character pointer unless the
  *	user was not found.
  */
 const	struct passwd *
 ff_getpw(const char **pp, const char *p_end)
 {
 	const	char		*p	= *pp;
 	const	char		*p1;
 	unsigned		len;
 	const	struct passwd	*pw;
 	int			count;
 
 	++p;	/* skip the tilde */
 	p1 = p;
 	while (p1 < p_end && *p1 != '/') ++p1;
 	len = p1 - p;
 
 	if (len != 0) {
 	    if (len >= ffline_len)
 		expandline(len);
 	    bcopy(p, ffline, len);
 	    ffline[len] = '\0';
 	}
 
 	for (count = 0;; ++count) {
 	    if (len == 0)	/* if no user name */
 		pw = getpwuid(getuid());
 	    else
 		pw = getpwnam(ffline);
 
 	    if (pw != NULL) {
 		*pp = p1;
 		return pw;
 	    }
 
 	    /* On some systems, getpw{uid,nam} return without setting errno,
 	     * even if the call failed because of too many open files.
 	     * Therefore, we play it safe here.
 	     */
 	    if (count >= 2 && len != 0 && getpwuid(getuid()) != NULL)
 		return NULL;
 	}
 }
 
 /*
  *
  *      Read size bytes from the FILE fp, constructing them into a
  *      signed/unsigned integer.
  *
  */
 unsigned long
 num(FILE *fp, int size)
 {
 	long	x	= 0;
 
 	while (size--)
 		x = (x << 8) | one(fp);
 	return x;
 }
 
 long
 snum(FILE *fp, int size)
 {
 	long	x;
 
 	x = (signed char) getc(fp);
 	while (--size)
 		x = (x << 8) | one(fp);
 	return x;
 }
 
 /*
  *	General AVL tree mechanism.  Search for a node, and return it if found.
  *	Otherwise insert a node.
  *	This uses the AVL algorithm from Knuth Vol. 3.
  */
 struct avl *
 avladd(const char *key, size_t key_len, struct avl **headp, size_t size)
 {
 	struct avl	*ap;
 	struct avl	**app;
 	struct avl	*sp;	/* place where rebalancing may be necessary */
 	struct avl	**spp;	/* points to sp */
 	int		i;
 
 	/* Search */
 	spp = app = headp;
 	for (;;) {
 	    ap = *app;
 	    if (ap == NULL)	/* bottom of tree */
 		break;
 	    if (ap->bal != 0)
 		spp = app;
 	    i = key_len - ap->key_len;
 	    if (i == 0)
 		i = memcmp(key, ap->key, key_len);
 	    if (i == 0)		/* found record already */
 		return ap;
 	    if (i < 0)		/* move left */
 		app = &ap->left;
 	    else
 		app = &ap->right;
 	}
 
 	/* Insert */
 	ap = xmalloc(size);
 	ap->key = key;
 	ap->key_len = key_len;
 	ap->bal = 0;
 	ap->left = ap->right = NULL;
 	*app = ap;
 
 	/* Adjust balance factors */
 	sp = *spp;
 	if (sp == ap)
 	    return ap;
 	i = key_len - sp->key_len;
 	if (i == 0)
 	    i = memcmp(key, sp->key, key_len);
 	sp = (i < 0 ? sp->left : sp->right);
 	while (sp != ap) {
 	    i = key_len - sp->key_len;
 	    if (i == 0)
 		i = memcmp(key, sp->key, key_len);
 	    if (i < 0) {
 		sp->bal = -1;
 		sp = sp->left;
 	    }
 	    else {
 		sp->bal = 1;
 		sp = sp->right;
 	    }
 	}
 
 	/* Balancing act */
 	sp = *spp;
 	i = key_len - sp->key_len;
 	if (i == 0)
 	    i = memcmp(key, sp->key, key_len);
 	if (i < 0) {
 	    if (sp->bal >= 0)
 		--sp->bal;
 	    else {	/* need to rebalance */
 		struct avl *left;
 
 		left = sp->left;
 		if (left->bal < 0) {	/* single rotation */
 		    sp->left = left->right;
 		    left->right = sp;
 		    sp->bal = left->bal = 0;
 		    *spp = left;
 		}
 		else {			/* double rotation */
 		    struct avl	*newtop;
 
 		    newtop = left->right;
 		    sp->left = newtop->right;
 		    newtop->right = sp;
 		    left->right = newtop->left;
 		    newtop->left = left;
 		    sp->bal = left->bal = 0;
 		    if (newtop->bal < 0) ++sp->bal;
 		    else if (newtop->bal > 0) --left->bal;
 		    newtop->bal = 0;
 		    *spp = newtop;
 		}
 	    }
 	}
 	else {
 	    if (sp->bal <= 0)
 		++sp->bal;
 	    else {	/* need to rebalance */
 		struct avl *right;
 
 		right = sp->right;
 		if (right->bal > 0) {	/* single rotation */
 		    sp->right = right->left;
 		    right->left = sp;
 		    sp->bal = right->bal = 0;
 		    *spp = right;
 		}
 		else {			/* double rotation */
 		    struct avl	*newtop;
 
 		    newtop = right->left;
 		    sp->right = newtop->left;
 		    newtop->left = sp;
 		    right->left = newtop->right;
 		    newtop->right = right;
 		    sp->bal = right->bal = 0;
 		    if (newtop->bal > 0) --sp->bal;
 		    else if (newtop->bal < 0) ++right->bal;
 		    newtop->bal = 0;
 		    *spp = newtop;
 		}
 	    }
 	}
 
 	return ap;
 }
 
 /*
  * Try and parse dest_url[] as a url:
  * - ignore protocol if found
  * - hostname is either what's remaining or up to a colon or slash character
  * - if colon is found, port number is either what is remaining or up to slash
  *   character
  * - if slash is found the rest of the string is a document path
  *
  * On success a struct url pointer is returned that the caller must
  * free, otherwise NULL returned.
  */
 struct url *
 parse_url(const char dest_url[])
 {
 	struct url	*url;
 	char		*sep_url;
 	char		*proto_loc;
 	char		*reset;
 
 	url = xmalloc(sizeof(struct url));
 	url->port = "443";
 	url->orig_url = dest_url;
 	url->document = "";
 
 	/* dest_url[] will be modified */
 	sep_url = xstrdup(dest_url);
 
 	/* Do not care if this is specified, https is assumed. */
 	if ((proto_loc = strstr(sep_url, "://")) != NULL) {
 		*proto_loc = '\0';
 		if (strcmp(sep_url, "https") != 0)
 			warnx("ignoring scheme '%s'", sep_url);
 		sep_url = proto_loc + strlen("://");
 	}
 
 	url->hostname = sep_url;
 
 	reset = strsep(&sep_url, ":");
 	if (sep_url != NULL)
 		url->port = sep_url;
 	else
 		sep_url = reset;
 
 	strsep(&sep_url, "/");
 	if (sep_url != NULL)
 		/* / was found, set document path */
 		url->document = sep_url;
 
 	return url;
 }