libisofs-legacy/libisofs/util.c

/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
/* vim: set ts=8 sts=8 sw=8 noet : */

#include <ctype.h>
#include <iconv.h>
#include <stdlib.h>
#include <stdint.h>
#include <langinfo.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <stdio.h>

#include "util.h"

int valid_d_char(char c)
{
	return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c == '_');
}

int valid_a_char(char c)
{
	return (c >= ' ' && c <= '"') || (c >= '%' && c <= '?') || (c >= 'A' &&
								    c <= 'Z')
		|| (c == '_');
}

int valid_j_char(char msb, char lsb)
{
	return !(msb == '\0' &&
		 (lsb < ' ' || lsb == '*' || lsb == '/' || lsb == ':' ||
		  lsb == ';' || lsb == '?' || lsb == '\\'));
}

int valid_p_char(char c)
{
	return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' &&
								    c <= 'z')
		|| (c == '.') || (c == '_') || (c == '-');
}

char *iso_d_str(const char *src, int size, int pad)
{
	char *dest = strlen(src) > size ||
		pad ? malloc(size + 1) : malloc(strlen(src) + 1);
	int i;

	/* Try converting to upper-case before validating. */
	for (i = 0; i < size && src[i]; i++) {
		char c = toupper(src[i]);

		dest[i] = valid_d_char(c) ? c : '_';
	}

	/* Optionally pad with spaces and terminate with NULL. */
	if (pad)
		while (i < size)
			dest[i++] = ' ';
	dest[i] = '\0';

	return dest;
}

char *iso_a_str(const char *src, int size)
{
	char *dest = malloc(size + 1);
	int i;

	for (i = 0; i < size && src[i]; i++) {
		char c = toupper(src[i]);

		dest[i] = valid_a_char(c) ? c : '_';
	}
	while (i < size)
		dest[i++] = ' ';
	dest[i] = '\0';

	return dest;
}

uint16_t *iso_j_str(const char *src)
{
	int size = strlen(src) * 2;
	uint16_t *dest = malloc(size + 2);
	char *cpy, *in, *out;
	size_t inleft, outleft;
	iconv_t cd;

	/* If the conversion is unavailable, return NULL. Obviously,
	   nl_langinfo(..) requires the locale to be set correctly. */
	cd = iconv_open("UCS-2BE", nl_langinfo(CODESET));
	if (cd == (iconv_t) - 1) {
		free(dest);
		return NULL;
	}

	/* In, out, inleft and outleft will be updated by iconv, that's why we 
	   need separate variables. */
	cpy = strdup(src); /* iconv doesn't take const * chars, so we need our
			    * own copy. */
	in = cpy;
	out = (char*)dest;
	inleft = strlen(cpy);
	outleft = size;
	iconv(cd, &in, &inleft, &out, &outleft);

	/* Since we need to pad with NULLs, we can pad up to and including the 
	   terminating NULLs. */
	outleft += 2;
	while (outleft) {
		*out++ = '\0';
		outleft--;
	}
	iconv_close(cd);
	free(cpy);

	return dest;
}

char *iso_1_fileid(const char *src)
{
	char *dest = malloc(15);	/* 15 = 8 (name) + 1 (.) + 3 (ext) + 2 
					   (;1) + 1 (\0) */
	char *dot = strrchr(src, '.');	/* Position of the last dot in the
					   filename, will be used to calculate 
					   lname and lext. */
	int lname, lext, pos, i;

	lext = dot ? strlen(dot + 1) : 0;
	lname = strlen(src) - lext - (dot ? 1 : 0);

	/* If we can't build a filename, return NULL. */
	if (lname == 0 && lext == 0) {
		free(dest);
		return NULL;
	}

	pos = 0;
	/* Convert up to 8 characters of the filename. */
	for (i = 0; i < lname && i < 8; i++) {
		char c = toupper(src[i]);

		dest[pos++] = valid_d_char(c) ? c : '_';
	}
	/* This dot is mandatory, even if there is no extension. */
	dest[pos++] = '.';
	/* Convert up to 3 characters of the extension, if any. */
	for (i = 0; i < lext && i < 3; i++) {
		char c = toupper(src[lname + 1 + i]);

		dest[pos++] = valid_d_char(c) ? c : '_';
	}
	/* File versions are mandatory, even if they aren't used. */
	dest[pos++] = ';';
	dest[pos++] = '1';
	dest[pos] = '\0';
	dest = (char *)realloc(dest, pos + 1);

	return dest;
}

char *iso_2_fileid(const char *src)
{
	char *dest = malloc(34);	/* 34 = 30 (name + ext) + 1 (.) + 2
					   (;1) + 1 (\0) */
	char *dot = strrchr(src, '.');
	int lname, lext, lnname, lnext, pos, i;

	/* Since the maximum length can be divided freely over the name and
	   extension, we need to calculate their new lengths (lnname and
	   lnext). If the original filename is too long, we start by trimming
	   the extension, but keep a minimum extension length of 3. */
	if (dot == NULL || dot == src || *(dot + 1) == '\0') {
		lname = strlen(src);
		lnname = (lname > 30) ? 30 : lname;
		lext = lnext = 0;
	} else {
		lext = strlen(dot + 1);
		lname = strlen(src) - lext - 1;
		lnext = (strlen(src) > 31 &&
			 lext > 3) ? (lname < 27 ? 30 - lname : 3) : lext;
		lnname = (strlen(src) > 31) ? 30 - lnext : lname;
	}

	if (lnname == 0 && lnext == 0) {
		free(dest);
		return NULL;
	}

	pos = 0;
	/* Convert up to lnname characters of the filename. */
	for (i = 0; i < lnname; i++) {
		char c = toupper(src[i]);

		dest[pos++] = valid_d_char(c) ? c : '_';
	}
	dest[pos++] = '.';
	/* Convert up to lnext characters of the extension, if any. */
	for (i = 0; i < lnext; i++) {
		char c = toupper(src[lname + 1 + i]);

		dest[pos++] = valid_d_char(c) ? c : '_';
	}
	dest[pos++] = ';';
	dest[pos++] = '1';
	dest[pos] = '\0';
	dest = (char *)realloc(dest, pos + 1);

	return dest;
}

uint16_t *iso_j_id(char *src)
{
	char *dest = malloc(136);	/* 136 = 128 (name + ext) + 2 (\0 .) + 
					   4 (\0 ; \0 1) + 2 (\0 \0) */
	char *dot = strrchr(src, '.');
	int lname, lext, lcname, lcext, lnname, lnext, pos, i;
	size_t inleft, outleft;
	char *cname, *cext, *in, *out;
	iconv_t cd;

	if (dot == NULL || dot == src || *(dot + 1) == '\0') {
		lname = strlen(src);
		lext = 0;
	} else {
		lext = strlen(dot + 1);
		lname = strlen(src) - lext - 1;
	}

	if (lname == 0 && lext == 0) {
		free(dest);
		return NULL;
	}

	cd = iconv_open("UCS-2BE", nl_langinfo(CODESET));
	if (cd == (iconv_t) - 1) {
		free(dest);
		return NULL;
	}

	/* We need to convert the name and extension first, in order to
	   calculate the number of characters they have. */
	cname = malloc(lname * 2);
	in = src;
	out = cname;
	inleft = lname;
	outleft = lname * 2;
	iconv(cd, &in, &inleft, &out, &outleft);
	lcname = (lname * 2) - outleft;
	iconv_close(cd);

	if (lext) {
		cd = iconv_open("UCS-2BE", nl_langinfo(CODESET));
		if (cd == (iconv_t) - 1) {
			free(dest);
			free(cname);
			return NULL;
		}
		cext = malloc(lext * 2);
		in = dot + 1;
		out = cext;
		inleft = lext;
		outleft = lext * 2;
		iconv(cd, &in, &inleft, &out, &outleft);
		lcext = (lext * 2) - outleft;
		iconv_close(cd);
	} else
		lcext = 0;

	/* Again, divide the available characters over name and extension, but 
	   keep a minimum of three characters for the new extension. */
	lnext = (lcname + lcext > 128 &&
		 lcext > 6) ? (lcname < 122 ? 128 - lcname : 6) : lcext;
	lnname = (lcname + lcext > 128) ? 128 - lnext : lcname;

	pos = 0;
	/* Copy up to lnname bytes from the converted filename. */
	for (i = 0; i < lnname; i = i + 2)
		if (valid_j_char(cname[i], cname[i + 1])) {
			dest[pos++] = cname[i];
			dest[pos++] = cname[i + 1];
		} else {
			dest[pos++] = '\0';
			dest[pos++] = '_';
		}
	/* Dot is now a 16 bit separator. */
	dest[pos++] = '\0';
	dest[pos++] = '.';
	/* Copy up to lnext bytes from the converted extension, if any. */
	for (i = 0; i < lnext; i = i + 2)
		if (valid_j_char(cext[i], cext[i + 1])) {
			dest[pos++] = cext[i];
			dest[pos++] = cext[i + 1];
		} else {
			dest[pos++] = '\0';
			dest[pos++] = '_';
		}
	/* Again, 2 bytes per character. */
	dest[pos++] = '\0';
	dest[pos++] = ';';
	dest[pos++] = '\0';
	dest[pos++] = '1';
	dest[pos++] = '\0';
	dest[pos] = '\0';

	dest = (char *)realloc(dest, pos + 1);
	free(cname);
	if (lext)
		free(cext);

	/* Fill in the size in bytes (including the terminating NULLs) of the
	   destination string. */
	return (uint16_t *) dest;
}

char *iso_p_filename(const char *src)
{
	char *dest = malloc(251);	/* We can fit up to 250 characters in
					   a Rock Ridge name entry. */
	char *dot = strrchr(src, '.');
	int lname, lext, lnname, lnext, pos, i;

	if (dot == NULL || dot == src || *(dot + 1) == '\0') {
		lname = strlen(src);
		lnname = (lname > 250) ? 250 : lname;
		lext = lnext = 0;
	} else {
		lext = strlen(dot + 1);
		lname = strlen(src) - lext - 1;
		lnext = (strlen(src) > 250 &&
			 lext > 3) ? (lname < 246 ? 249 - lname : 3) : lext;
		lnname = (strlen(src) > 250) ? 249 - lnext : lname;
	}

	if (lnname == 0 && lnext == 0) {
		free(dest);
		return NULL;
	}

	pos = 0;
	for (i = 0; i < lnname; i++)
		dest[pos++] = valid_p_char(src[i]) ? src[i] : '_';
	if (lnext) {
		dest[pos++] = '.';
		for (i = 0; i < lnext; i++)
			dest[pos++] =
				valid_p_char(src[lname + 1 + i]) ?
					     src[lname + 1 + i] : '_';
	}
	dest[pos] = '\0';
	dest = (char *)realloc(dest, pos + 1);

	return dest;
}

char *iso_p_dirname(const char *src)
{
	char *dest = strlen(src) > 250 ? malloc(251) : malloc(strlen(src) + 1);
	int i;

	if (strlen(src) == 0) {
		free(dest);
		return NULL;
	}

	for (i = 0; i < 250 && src[i]; i++)
		dest[i] = valid_p_char(src[i]) ? src[i] : '_';
	dest[i] = '\0';

	return dest;
}

char *iso_pathname(const char *dir, const char *file)
{
	char *path = malloc(strlen(dir) + strlen(file) + 2);

	strcpy(path, dir);
	path[strlen(dir)] = '/';
	strcpy(path + strlen(dir) + 1, file);

	return path;
}

void iso_a_strcpy(unsigned char *dest, int size, const char *src)
{
	int i = 0, d = 0;

	if (src)
		for (; i < size && *src; ++i, ++src) {
			char s = toupper(*src);

			if (valid_a_char(s))
				dest[d++] = s;
			else
				dest[d++] = '_';
		}
	for (; i < size; ++i) {
		/* pad with spaces */
		dest[d++] = ' ';
	}
}

void iso_d_strcpy(unsigned char *dest, int size, const char *src)
{
	int i = 0, d = 0;

	if (src)
		for (; i < size && *src; ++i, ++src) {
			char s = toupper(*src);

			if (valid_d_char(s))
				dest[d++] = s;
			else
				dest[d++] = '_';
		}
	for (; i < size; ++i) {
		/* pad with spaces */
		dest[d++] = ' ';
	}
}

char *iso_a_strndup(const char *src, int size)
{
	int i, d;
	char *out;

	out = malloc(size + 1);
	for (i = d = 0; i < size && *src; ++i, ++src) {
		char s = toupper(*src);

		if (valid_a_char(s))
			out[d++] = s;
		else
			out[d++] = '_';
	}
	out[d++] = '\0';
	out = realloc(out, d);	/* shrink the buffer to what we used */
	return out;
}

char *iso_d_strndup(const char *src, int size)
{
	int i, d;
	char *out;

	out = malloc(size + 1);
	for (i = d = 0; i < size && *src; ++i, ++src) {
		char s = toupper(*src);

		if (valid_d_char(s))
			out[d++] = s;
		else
			out[d++] = '_';
	}
	out[d++] = '\0';
	out = realloc(out, d);	/* shrink the buffer to what we used */
	return out;
}

char *iso_strconcat(char sep, const char *a, const char *b)
{
	char *out;
	int la, lb;

	la = strlen(a);
	lb = strlen(b);
	out = malloc(la + lb + 1 + (sep ? 1 : 0));
	memcpy(out, a, la);
	memcpy(out + la + (sep ? 1 : 0), b, lb);
	if (sep)
		out[la] = sep;
	out[la + lb + (sep ? 1 : 0)] = '\0';
	return out;
}

char *iso_strdup(const char *src)
{
	return src ? strdup(src) : NULL;
}

void iso_lsb(uint8_t *buf, uint32_t num, int bytes)
{
	int i;

	assert(bytes <= 4);

	for (i = 0; i < bytes; ++i)
		buf[i] = (num >> (8 * i)) & 0xff;
}

void iso_msb(uint8_t *buf, uint32_t num, int bytes)
{
	int i;

	assert(bytes <= 4);

	for (i = 0; i < bytes; ++i)
		buf[bytes - 1 - i] = (num >> (8 * i)) & 0xff;
}

void iso_bb(uint8_t *buf, uint32_t num, int bytes)
{
	iso_lsb(buf, num, bytes);
	iso_msb(buf+bytes, num, bytes);
}


void iso_datetime_7(unsigned char *buf, time_t t)
{
	static int tzsetup = 0;
	static int tzoffset;
	struct tm tm;

	if (!tzsetup) {
		tzset();

		tzoffset = -timezone / 60 / 15;
		if (tzoffset < -48)
			tzoffset += 101;

		tzsetup = 1;
	}

	localtime_r(&t, &tm);

	buf[0] = tm.tm_year;
	buf[1] = tm.tm_mon + 1;
	buf[2] = tm.tm_mday;
	buf[3] = tm.tm_hour;
	buf[4] = tm.tm_min;
	buf[5] = tm.tm_sec;
	buf[6] = tzoffset;
}

time_t iso_datetime_read_7(const uint8_t *buf)
{
	struct tm tm;

	tm.tm_year = buf[0];
	tm.tm_mon = buf[1] + 1;
	tm.tm_mday = buf[2];
	tm.tm_hour = buf[3];
	tm.tm_min = buf[4];
	tm.tm_sec = buf[5];

	return mktime(&tm) - buf[6] * 60 * 60;
}

void iso_datetime_17(unsigned char *buf, time_t t)
{
	static int tzsetup = 0;
	static int tzoffset;
	struct tm tm;
	char c[5];

	if (t == (time_t) - 1) {
		/* unspecified time */
		memset(buf, '0', 16);
		buf[16] = 0;
	} else {
		if (!tzsetup) {
			tzset();

			tzoffset = -timezone / 60 / 15;
			if (tzoffset < -48)
				tzoffset += 101;

			tzsetup = 1;
		}

		localtime_r(&t, &tm);

		/* year */
		sprintf(c, "%04d", tm.tm_year + 1900);
		memcpy(&buf[0], c, 4);
		/* month */
		sprintf(c, "%02d", tm.tm_mon + 1);
		memcpy(&buf[4], c, 2);
		/* day */
		sprintf(c, "%02d", tm.tm_mday);
		memcpy(&buf[6], c, 2);
		/* hour */
		sprintf(c, "%02d", tm.tm_hour);
		memcpy(&buf[8], c, 2);
		/* minute */
		sprintf(c, "%02d", tm.tm_min);
		memcpy(&buf[10], c, 2);
		/* second */
		sprintf(c, "%02d", MIN(59, tm.tm_sec));
		memcpy(&buf[12], c, 2);
		/* hundreths */
		memcpy(&buf[14], "00", 2);
		/* timezone */
		buf[16] = tzoffset;
	}
}

time_t iso_datetime_read_17(const uint8_t *buf)
{
	struct tm tm;

	sscanf((char*)&buf[0], "%4d", &tm.tm_year);
	sscanf((char*)&buf[4], "%2d", &tm.tm_mon);
	sscanf((char*)&buf[6], "%2d", &tm.tm_mday);
	sscanf((char*)&buf[8], "%2d", &tm.tm_hour);
	sscanf((char*)&buf[10], "%2d", &tm.tm_min);
	sscanf((char*)&buf[12], "%2d", &tm.tm_sec);
	tm.tm_year -= 1900;
	tm.tm_mon -= 1;

	return mktime(&tm) - buf[16] * 60 * 60;
}

void iso_split_filename(char *name, char **ext)
{
	char *r;

	r = strrchr(name, '.');
	if (r) {
		*r = '\0';
		*ext = r + 1;
	} else
		*ext = "";
}

void iso_filecpy(unsigned char *buf, int size, const char *name, int version)
{
	char v[6];
	int nl, vl;

	assert(version >= 0);
	assert(version < 0x8000);

	nl = strlen(name);

	memcpy(buf, name, nl);

	if (!version)
		assert(size >= strlen(name));
	else {
		sprintf(v, "%d", version);
		vl = strlen(v);
		assert(size >= nl + vl + 1);

		buf[nl] = ';';
		memcpy(&buf[nl + 1], v, vl);

		nl += vl + 1;
	}
	/* pad with spaces */
	if (nl < size)
		memset(&buf[nl], ' ', size - nl);
}

size_t ucslen(const uint16_t *str)
{
	int i;

	for (i=0; str[i]; i++)
		;
	return i;
}

int ucscmp(const uint16_t *s1, const uint16_t *s2)
{
	int i;

	for (i=0; 1; i++) {
		if (s1[i] < s2[i]) {
			return -1;
		} else if (s1[i] > s2[i]) {
			return 1;
		} else if (s1[i] == 0 && s2[i] == 0) {
			break;
		}
	}

	return 0;
}

uint32_t iso_read_lsb(const uint8_t *buf, int bytes)
{
	int i;
	uint32_t ret = 0;

	for (i=0; i<bytes; i++) {
		ret += ((uint32_t) buf[i]) << (i*8);
	}
	return ret;
}

uint32_t iso_read_msb(const uint8_t *buf, int bytes)
{
	int i;
	uint32_t ret = 0;

	for (i=0; i<bytes; i++) {
		ret += ((uint32_t) buf[bytes-i-1]) << (i*8);
	}
	return ret;
}

uint32_t iso_read_bb(const uint8_t *buf, int bytes)
{
	uint32_t v1 = iso_read_lsb(buf, bytes);
	uint32_t v2 = iso_read_msb(buf+bytes, bytes);

	assert(v1 == v2);
	return v1;
}