/* vfat.c
 *
 * Miscellaneous VFAT-related functions
 */

#include "sysincludes.h"
#include "msdos.h"
#include "mtools.h"
#include "vfat.h"
#include "file.h"
#include "dirCache.h"

/* #define DEBUG */

const char *short_illegals=";+=[]',\"*\\<>/?:|";
const char *long_illegals = "\"*\\<>/?:|\005";

/* Automatically derive a new name */
static void autorename(char *name,
		       char tilda, char dot, const char *illegals,
		       int limit, int bump)
{
	int tildapos, dotpos;
	unsigned int seqnum=0, maxseq=0;
	char tmp;
	char *p;
	
#ifdef DEBUG
	printf("In autorename for name=%s.\n", name);
#endif
	tildapos = -1;

	for(p=name; *p ; p++)
		if((*p < ' ' && *p != '\005') || strchr(illegals, *p)) {
			*p = '_';
			bump = 0;
		}

	for(dotpos=0;
	    name[dotpos] && dotpos < limit && name[dotpos] != dot ;
	    dotpos++) {
		if(name[dotpos] == tilda) {
			tildapos = dotpos;
			seqnum = 0;
			maxseq = 1;
		} else if (name[dotpos] >= '0' && name[dotpos] <= '9') {
			seqnum = seqnum * 10 + name[dotpos] - '0';
			maxseq = maxseq * 10;
		} else
			tildapos = -1; /* sequence number interrupted */
	}
	if(tildapos == -1) {
		/* no sequence number yet */
		if(dotpos > limit - 2) {
			tildapos = limit - 2;
			dotpos = limit;
		} else {
			tildapos = dotpos;
			dotpos += 2;
		}
		seqnum = 1;
	} else {
		if(bump)
			seqnum++;
		if(seqnum > 999999) {
			seqnum = 1;
			tildapos = dotpos - 2;
			/* this matches Win95's behavior, and also guarantees
			 * us that the sequence numbers never get shorter */
		}
		if (seqnum == maxseq) {
		    if(dotpos >= limit)
			tildapos--;
		    else
			dotpos++;
		}
	}

	tmp = name[dotpos];
	if((bump && seqnum == 1) || seqnum > 1 || mtools_numeric_tail)
		sprintf(name+tildapos,"%c%d",tilda, seqnum);
	if(dot)
	    name[dotpos]=tmp;
	/* replace the character if it wasn't a space */
}


void autorename_short(char *name, int bump)
{
	autorename(name, '~', ' ', short_illegals, 8, bump);
}

void autorename_long(char *name, int bump)
{
	autorename(name, '-', '\0', long_illegals, 255, bump);
}


static inline int unicode_read(struct unicode_char *in, char *out, int num)
{
	char *end_out = out+num;

	while(out < end_out) {
		if (in->uchar)
			*out = '_';
		else
			*out = in->lchar;
		++out;
		++in;
	}
	return num;
}


void clear_vfat(struct vfat_state *v)
{
	v->subentries = 0;
	v->status = 0;
	v->present = 0;
}


/* sum_shortname
 *
 * Calculate the checksum that results from the short name in *dir.
 *
 * The sum is formed by circularly right-shifting the previous sum
 * and adding in each character, from left to right, padding both
 * the name and extension to maximum length with spaces and skipping
 * the "." (hence always summing exactly 11 characters).
 * 
 * This exact algorithm is required in order to remain compatible
 * with Microsoft Windows-95 and Microsoft Windows NT 3.5.
 * Thanks to Jeffrey Richter of Microsoft Systems Journal for
 * pointing me to the correct algorithm.
 *
 * David C. Niemi (niemi@tux.org) 95.01.19
 */
static inline unsigned char sum_shortname(char *name)
{
	unsigned char sum;
	char *end = name+11;

	for (sum=0; name<end; ++name)
		sum = ((sum & 1) ? 0x80 : 0) + (sum >> 1) 
		  + (*name ? *name : ' ');
	return(sum);
}

/* check_vfat
 *
 * Inspect a directory and any associated VSEs.
 * Return 1 if the VSEs comprise a valid long file name,
 * 0 if not.
 */
static inline void check_vfat(struct vfat_state *v, struct directory *dir)
{
	char name[12];

	if (! v->subentries) {
#ifdef DEBUG
		fprintf(stderr, "check_vfat: no VSEs.\n");
#endif
		return;
	}

	strncpy((char *)name, (char *)dir->name, 8);
	strncpy((char *)name + 8, (char *)dir->ext, 3);
	name[11] = '\0';

	if (v->sum != sum_shortname(name))
		return;
	
	if( (v->status & ((1<<v->subentries) - 1)) != (1<<v->subentries) - 1)
		return; /* missing entries */

	/* zero out byte following last entry, for good measure */
	v->name[VSE_NAMELEN * v->subentries] = 0;
	v->present = 1;
}


int clear_vses(Stream_t *Dir, int entrySlot, size_t last)
{
	direntry_t entry;
	dirCache_t *cache;
	int error;

	entry.Dir = Dir;
	entry.entry = entrySlot;

	/*maximize(last, entry.entry + MAX_VFAT_SUBENTRIES);*/
	cache = allocDirCache(Dir, last);
	if(!cache) {
		fprintf(stderr, "Out of memory error in clear_vses\n");
		exit(1);
	}
	addFreeEntry(cache, entry.entry, last);
	for (; entry.entry < last; ++entry.entry) {
#ifdef DEBUG
		fprintf(stderr,"Clearing entry %d.\n", entry.entry);
#endif
		dir_read(&entry, &error);
		if(error)
		    return error;
		if(!entry.dir.name[0] || entry.dir.name[0] == DELMARK)
			break;
		entry.dir.name[0] = DELMARK;
		if (entry.dir.attr == 0xf)
			entry.dir.attr = '\0';
		low_level_dir_write(&entry);
	}
	return 0;
}

int write_vfat(Stream_t *Dir, char *shortname, char *longname, int start,
	       direntry_t *mainEntry)
{
	struct vfat_subentry *vse;
	int vse_id, num_vses;
	char *c;
	direntry_t entry;
	dirCache_t *cache;
	char unixyName[13];
	
	if(longname) {
#ifdef DEBUG
		printf("Entering write_vfat with longname=\"%s\", start=%d.\n",
		       longname,start);
#endif
		entry.Dir = Dir;
		vse = (struct vfat_subentry *) &entry.dir;
		/* Fill in invariant part of vse */
		vse->attribute = 0x0f;
		vse->hash1 = vse->sector_l = vse->sector_u = 0;
		vse->sum = sum_shortname(shortname);
#ifdef DEBUG
		printf("Wrote checksum=%d for shortname %s.\n", 
		       vse->sum,shortname);
#endif
		num_vses = strlen(longname)/VSE_NAMELEN + 1;
		for (vse_id = num_vses; vse_id; --vse_id) {
			int end = 0;
			
			c = longname + (vse_id - 1) * VSE_NAMELEN;
			
			c += unicode_write(c, vse->text1, VSE1SIZE, &end);
			c += unicode_write(c, vse->text2, VSE2SIZE, &end);
			c += unicode_write(c, vse->text3, VSE3SIZE, &end);

			vse->id = (vse_id == num_vses) ? (vse_id | VSE_LAST) : vse_id;
#ifdef DEBUG
			printf("Writing longname=(%s), VSE %d (%13s) at %d, end = %d.\n",
			       longname, vse_id, longname + (vse_id-1) * VSE_NAMELEN,
			       start + num_vses - vse_id, start + num_vses);
#endif
			
			entry.entry = start + num_vses - vse_id;
			low_level_dir_write(&entry);
		}
	} else
		num_vses = 0;
	cache = allocDirCache(Dir, start + num_vses + 1);
	if(!cache) {
		fprintf(stderr, "Out of memory error\n");
		exit(1);
	}
	unix_name(shortname, shortname+8, 0, unixyName);
	addUsedEntry(cache, start, start + num_vses + 1, longname, unixyName,
		     &mainEntry->dir);
	low_level_dir_write(mainEntry);
	return start + num_vses;
}

void dir_write(direntry_t *entry)
{
	dirCacheEntry_t *dce;
	dirCache_t *cache;

	if(entry->entry == -3) {
		fprintf(stderr, "Attempt to write root directory pointer\n");
		exit(1);
	}

	cache = allocDirCache(entry->Dir, entry->entry + 1);
	if(!cache) {
		fprintf(stderr, "Out of memory error in dir_write\n");
		exit(1);
	}
	dce = cache->entries[entry->entry];
	if(dce) {
		if(entry->dir.name[0] == DELMARK) {
			addFreeEntry(cache, dce->beginSlot, dce->endSlot);
		} else {
			dce->dir = entry->dir;
		}
	}
	low_level_dir_write(entry);
}


/* 
 * The following function translates a series of vfat_subentries into
 * data suitable for a dircache entry
 */
static inline void parse_vses(direntry_t *entry,			      
			      struct vfat_state *v)
{
	struct vfat_subentry *vse;
	unsigned char id, last_flag;
	char *c;
	
	vse = (struct vfat_subentry *) &entry->dir;
	
	id = vse->id & VSE_MASK;
	last_flag = (vse->id & VSE_LAST);
	if (id > MAX_VFAT_SUBENTRIES) {
		fprintf(stderr, "parse_vses: invalid VSE ID %d at %d.\n",
			id, entry->entry);
		return;
	}
	
/* 950819: This code enforced finding the VSEs in order.  Well, Win95
 * likes to write them in *reverse* order for some bizarre reason!  So
 * we pretty much have to tolerate them coming in any possible order.
 * So skip this check, we'll do without it (What does this do, Alain?).
 *
 * 950820: Totally rearranged code to tolerate any order but to warn if
 * they are not in reverse order like Win95 uses.
 *
 * 950909: Tolerate any order. We recognize new chains by mismatching
 * checksums. In the event that the checksums match, new entries silently
 * overwrite old entries of the same id. This should accept all valid
 * entries, but may fail to reject invalid entries in some rare cases.
 */

	/* bad checksum, begin new chain */
	if(v->sum != vse->sum) {
		clear_vfat(v);
		v->sum = vse->sum;
	}
	
#ifdef DEBUG
	if(v->status & (1 << (id-1)))
		fprintf(stderr,
			"parse_vses: duplicate VSE %d\n", vse->id);
#endif
	
	v->status |= 1 << (id-1);
	if(last_flag)
		v->subentries = id;
	
#ifdef DEBUG
	if (id > v->subentries)
		/* simple test to detect entries preceding
		 * the "last" entry (really the first) */
		fprintf(stderr,
			"parse_vses: new VSE %d sans LAST flag\n",
			vse->id);
#endif

	c = &(v->name[VSE_NAMELEN * (id-1)]);
	c += unicode_read(vse->text1, c, VSE1SIZE);
	c += unicode_read(vse->text2, c, VSE2SIZE);
	c += unicode_read(vse->text3, c, VSE3SIZE);
#ifdef DEBUG
	printf("Read VSE %d at %d, subentries=%d, = (%13s).\n",
	       id,entry->entry,v->subentries,&(v->name[VSE_NAMELEN * (id-1)]));
#endif		
	if (last_flag)
		*c = '\0';	/* Null terminate long name */
}


static dirCacheEntry_t *vfat_lookup_loop_common(direntry_t *direntry,
						dirCache_t *cache,
						int lookForFreeSpace,
						int *io_error)
{
	char newfile[13];
	int initpos = direntry->entry + 1;
	struct vfat_state vfat;
	char *longname;
	int error;

	/* not yet cached */
	*io_error = 0;
	clear_vfat(&vfat);
	while(1) {
		++direntry->entry;
		if(!dir_read(direntry, &error)){
			if(error) {
			    *io_error = error;
			    return NULL;
			}
			addFreeEntry(cache, initpos, direntry->entry);
			return addEndEntry(cache, direntry->entry);
		}
		
		if (direntry->dir.name[0] == '\0'){
				/* the end of the directory */
			if(lookForFreeSpace)
				continue;
			return addEndEntry(cache, direntry->entry);
		}
		if(direntry->dir.name[0] != DELMARK &&
		   direntry->dir.attr == 0x0f)
			parse_vses(direntry, &vfat);
		else
			/* the main entry */
			break;
	}
	
	/* If we get here, it's a short name FAT entry, maybe erased.
	 * thus we should make sure that the vfat structure will be
	 * cleared before the next loop run */
	
	/* deleted file */
	if (direntry->dir.name[0] == DELMARK) {
		return addFreeEntry(cache, initpos, 
				    direntry->entry + 1);
	}
	
	check_vfat(&vfat, &direntry->dir);
	if(!vfat.present)
		vfat.subentries = 0;
	
	/* mark space between last entry and this one as free */
	addFreeEntry(cache, initpos, 
		     direntry->entry - vfat.subentries);
	
	if (direntry->dir.attr & 0x8){
		strncpy(newfile, direntry->dir.name,8);
		newfile[8]='\0';
		strncat(newfile, direntry->dir.ext,3);
		newfile[11]='\0';
	} else
		unix_name(direntry->dir.name, 
			  direntry->dir.ext, 
			  direntry->dir.Case, 
			  newfile);

	if(vfat.present)
		longname = vfat.name;
	else
		longname = 0;

	return addUsedEntry(cache, direntry->entry - vfat.subentries,
			    direntry->entry + 1, longname, 
			    newfile, &direntry->dir);
}

static inline dirCacheEntry_t *vfat_lookup_loop_for_read(direntry_t *direntry,
							 dirCache_t *cache,
							 int *io_error)
{
	int initpos = direntry->entry + 1;
	dirCacheEntry_t *dce;

	*io_error = 0;
	dce = cache->entries[initpos];
	if(dce) {
		direntry->entry = dce->endSlot - 1;
		return dce;
	} else {
		return vfat_lookup_loop_common(direntry, cache, 0, io_error);
	}
}


typedef enum result_t {
	RES_NOMATCH,
	RES_MATCH,
	RES_END,
	RES_ERROR
} result_t;


/* 
 * 0 does not match
 * 1 matches
 * 2 end
 */
static result_t checkNameForMatch(struct direntry_t *direntry, 
				  dirCacheEntry_t *dce,
				  const char *filename,
				  char *longname,
				  char *shortname,
				  int length,
				  int flags)
{
	switch(dce->type) {
		case DCET_FREE:
			return RES_NOMATCH;
		case DCET_END:
			return RES_END;
		case DCET_USED:
			break;
		default:
			fprintf(stderr, "Unexpected entry type %d\n",
				dce->type);
			return RES_ERROR;
	}

	direntry->dir = dce->dir;

	/* make sure the entry is of an accepted type */
	if((direntry->dir.attr & 0x8) && !(flags & ACCEPT_LABEL))
		return RES_NOMATCH;


	/*---------- multiple files ----------*/
	if(!((flags & MATCH_ANY) ||
	     (dce->longName && 
	      match(dce->longName, filename, direntry->name, 0, length)) ||
	     match(dce->shortName, filename, direntry->name, 1, length))) {

		return RES_NOMATCH;
	}

	/* entry of non-requested type, has to come after name
	 * checking because of clash handling */
	if(IS_DIR(direntry) && !(flags & ACCEPT_DIR)) {
		if(!(flags & (ACCEPT_LABEL|MATCH_ANY|NO_MSG)))
			fprintf(stderr,
				"Skipping \"%s\", is a directory\n",
				dce->shortName);
		return RES_NOMATCH;
	}

	if(!(direntry->dir.attr & (ATTR_LABEL | ATTR_DIR)) && 
	   !(flags & ACCEPT_PLAIN)) {
		if(!(flags & (ACCEPT_LABEL|MATCH_ANY|NO_MSG)))
			fprintf(stderr,
				"Skipping \"%s\", is not a directory\n",
				dce->shortName);
		return RES_NOMATCH;
	}

	return RES_MATCH;
}


/*
 * vfat_lookup looks for filenames in directory dir.
 * if a name if found, it is returned in outname
 * if applicable, the file is opened and its stream is returned in File
 */

int vfat_lookup(direntry_t *direntry, const char *filename, int length,
		int flags, char *shortname, char *longname)
{
	dirCacheEntry_t *dce;
	result_t result;
	dirCache_t *cache;
	int io_error;

	if(length == -1 && filename)
		length = strlen(filename);

	if (direntry->entry == -2)
		return -1;

	cache = allocDirCache(direntry->Dir, direntry->entry+1);
	if(!cache) {
		fprintf(stderr, "Out of memory error in vfat_lookup [0]\n");
		exit(1);
	}

	do {
		dce = vfat_lookup_loop_for_read(direntry, cache, &io_error);
		if(!dce) {
			if (io_error)
				return -2;
			fprintf(stderr, "Out of memory error in vfat_lookup\n");
			exit(1);
		}
		result = checkNameForMatch(direntry, dce,
					   filename, 
					   longname, shortname,
					   length, flags);
	} while(result == RES_NOMATCH);

	if(result == RES_MATCH){
		if(longname){
			if(dce->longName)
				strcpy(longname, dce->longName);
			else
				*longname ='\0';
		}
		if(shortname)
			strcpy(shortname, dce->shortName);
		direntry->beginSlot = dce->beginSlot;
		direntry->endSlot = dce->endSlot-1;
		return 0; /* file found */
	} else {
		direntry->entry = -2;
		return -1; /* no file found */
	}
}

static inline dirCacheEntry_t *vfat_lookup_loop_for_insert(direntry_t *direntry,
							   int initpos,
							   dirCache_t *cache)
{
	dirCacheEntry_t *dce;
	int io_error;

	dce = cache->entries[initpos];
	if(dce && dce->type != DCET_END) {
		return dce;
	} else {
		direntry->entry = initpos - 1;
		dce = vfat_lookup_loop_common(direntry, cache, 1, &io_error);
		if(!dce) {
			if (io_error) {
				return NULL;
			}
			fprintf(stderr, 
				"Out of memory error in vfat_lookup_loop\n");
			exit(1);
		}
		return cache->entries[initpos];
	}
}

static void accountFreeSlots(struct scan_state *ssp, dirCacheEntry_t *dce)
{
	if(ssp->got_slots)
		return;

	if(ssp->free_end != dce->beginSlot) {
		ssp->free_start = dce->beginSlot;
	}
	ssp->free_end = dce->endSlot;

	if(ssp->free_end - ssp->free_start >= ssp->size_needed) {
		ssp->got_slots = 1;
		ssp->slot = ssp->free_start + ssp->size_needed - 1;
	}
}

/* lookup_for_insert replaces the old scandir function.  It directly
 * calls into vfat_lookup_loop, thus eliminating the overhead of the
 * normal vfat_lookup
 */
int lookupForInsert(Stream_t *Dir,
					char *dosname,
					char *longname,
					struct scan_state *ssp, 
					int ignore_entry,
					int source_entry,
					int pessimisticShortRename)
{
	direntry_t entry;
	int ignore_match;
	dirCacheEntry_t *dce;
	dirCache_t *cache;
	int pos; /* position _before_ the next answered entry */
	char shortName[13];

	ignore_match = (ignore_entry == -2 );

	initializeDirentry(&entry, Dir);
	ssp->match_free = 0;

	/* hash bitmap of already encountered names.  Speeds up batch appends
	 * to huge directories, because in the best case, we only need to scan
	 * the new entries rather than the whole directory */
	cache = allocDirCache(Dir, 1);
	if(!cache) {
		fprintf(stderr, "Out of memory error in lookupForInsert\n");
		exit(1);
	}

	if(!ignore_match)
		unix_name(dosname, dosname + 8, 0, shortName);

	pos = cache->nrHashed;
	if(source_entry >= 0 ||
	   (pos && isHashed(cache, longname))) {
		pos = 0;
	} else if(pos && !ignore_match && isHashed(cache, shortName)) {
		if(pessimisticShortRename) {
			ssp->shortmatch = -2;
			return 1;
		}
		pos = 0;
	} else if(growDirCache(cache, pos) < 0) {
		fprintf(stderr, "Out of memory error in vfat_looup [0]\n");
		exit(1);
	}
	do {
		dce = vfat_lookup_loop_for_insert(&entry, pos, cache);
		switch(dce->type) {
			case DCET_FREE:
				accountFreeSlots(ssp, dce);
				break;
			case DCET_USED:
				if(!(dce->dir.attr & 0x8) &&
				   dce->endSlot - 1 == source_entry)
				   accountFreeSlots(ssp, dce);

				/* labels never match, neither does the 
				 * ignored entry */
				if( (dce->dir.attr & 0x8) ||
				    (dce->endSlot - 1 == ignore_entry) )
					break;

				/* check long name */
				if((dce->longName && 
				    !strcasecmp(dce->longName, longname)) ||
				   (dce->shortName &&
				    !strcasecmp(dce->shortName, longname))) {
					ssp->longmatch = dce->endSlot - 1;
					/* long match is a reason for
					 * immediate stop */
					return 1;
				}

				/* Long name or not, always check for 
				 * short name match */
				if (!ignore_match &&
				    !strcasecmp(shortName, dce->shortName))
					ssp->shortmatch = dce->endSlot - 1;
				break;
			case DCET_END:
				break;
		}
		pos = dce->endSlot;
	} while(dce->type != DCET_END);
	if (ssp->shortmatch > -1)
		return 1;
	ssp->max_entry = dce->beginSlot;
	if (ssp->got_slots)
		return 6;	/* Success */

	/* Need more room.  Can we grow the directory? */
	if(!isRootDir(Dir))		
		return 5;	/* OK, try to grow the directory */

	fprintf(stderr, "No directory slots\n");
	return -1;
}



/* End vfat.c */