/* mangle.c -- encode long filenames
   Copyright (C) 1988, 1992 Free Software Foundation

This file is part of GNU Tar.

GNU Tar 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, or (at your option)
any later version.

GNU Tar 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 GNU Tar; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include <stdio.h>
#include <sys/types.h>
#include <time.h>
time_t time();

#include "tar.h"
#include "port.h"

void add_buffer();
extern PTR ck_malloc();
void finish_header();
extern PTR init_buffer();
extern char *quote_copy_string();
extern char *get_buffer();
char *un_quote_string();

extern union record *start_header();

extern struct stat hstat;		/* Stat struct corresponding */

struct mangled {
	struct mangled *next;
	int type;
	char mangled[NAMSIZ];
	char *linked_to;
	char normal[1];
};


/* Should use a hash table, etc. .  */
struct mangled *first_mangle;
int mangled_num = 0;

#if 0 /* Deleted because there is now a better way to do all this */

char *
find_mangled (name)
char *name;
{
	struct mangled *munge;

	for(munge=first_mangle;munge;munge=munge->next)
		if(!strcmp(name,munge->normal))
			return munge->mangled;
	return 0;
}


#ifdef S_ISLNK
void
add_symlink_mangle(symlink, linkto, buffer)
char *symlink;
char *linkto;
char *buffer;
{
	struct mangled *munge,*kludge;

	munge=(struct mangled *)ck_malloc(sizeof(struct mangled)+strlen(symlink)+strlen(linkto)+2);
	if(!first_mangle)
		first_mangle=munge;
	else {
		for(kludge=first_mangle;kludge->next;kludge=kludge->next)
			;
		kludge->next=munge;
	}
	munge->type=1;
	munge->next=0;
	strcpy(munge->normal,symlink);
	munge->linked_to=munge->normal+strlen(symlink)+1;
	strcpy(munge->linked_to,linkto);
	sprintf(munge->mangled,"@@MaNgLeD.%d",mangled_num++);
	strncpy(buffer,munge->mangled,NAMSIZ);
}
#endif

void
add_mangle (name, buffer)
char *name;
char *buffer;
{
	struct mangled *munge,*kludge;

	munge=(struct mangled *)ck_malloc(sizeof(struct mangled)+strlen(name));
	if(!first_mangle)
		first_mangle=munge;
	else {
		for(kludge=first_mangle;kludge->next;kludge=kludge->next)
			;
		kludge->next=munge;
	}
	munge->next=0;
	munge->type=0;
	strcpy(munge->normal,name);
	sprintf(munge->mangled,"@@MaNgLeD.%d",mangled_num++);
	strncpy(buffer,munge->mangled,NAMSIZ);
}

void
write_mangled()
{
	struct mangled *munge;
	struct stat hstat;
	union record *header;
	char *ptr1,*ptr2;
	PTR the_buffer;
	int size;
	int bufsize;

	if(!first_mangle)
		return;
	the_buffer=init_buffer();
	for(munge=first_mangle,size=0;munge;munge=munge->next) {
		ptr1=quote_copy_string(munge->normal);
		if(!ptr1)
			ptr1=munge->normal;
		if(munge->type) {
			add_buffer(the_buffer,"Symlink ",8);
			add_buffer(the_buffer,ptr1,strlen(ptr1));
			add_buffer(the_buffer," to ",4);
			
			if(ptr2=quote_copy_string(munge->linked_to)) {
				add_buffer(the_buffer,ptr2,strlen(ptr2));
				free(ptr2);
			} else
				add_buffer(the_buffer,munge->linked_to,strlen(munge->linked_to));
		} else {
			add_buffer(the_buffer,"Rename ",7);
			add_buffer(the_buffer,munge->mangled,strlen(munge->mangled));
			add_buffer(the_buffer," to ",4);
			add_buffer(the_buffer,ptr1,strlen(ptr1));
		}
		add_buffer(the_buffer,"\n",1);
		if(ptr1!=munge->normal)
			free(ptr1);
	}

	bzero(&hstat,sizeof(struct stat));
	hstat.st_atime=hstat.st_mtime=hstat.st_ctime=time(0);
	ptr1=get_buffer(the_buffer);
	hstat.st_size=strlen(ptr1);

	header=start_header("././@MaNgLeD_NaMeS",&hstat);
	header->header.linkflag=LF_NAMES;
	finish_header(header);
	size=hstat.st_size;
	header=findrec();
	bufsize = endofrecs()->charptr - header->charptr;

	while(bufsize<size) {
		bcopy(ptr1,header->charptr,bufsize);
		ptr1+=bufsize;
		size-=bufsize;
		userec(header+(bufsize-1)/RECORDSIZE);
		header=findrec();
		bufsize = endofrecs()->charptr - header->charptr;
	}
	bcopy(ptr1,header->charptr,size);
	bzero(header->charptr+size,bufsize-size);
	userec(header+(size-1)/RECORDSIZE);
}

#endif

void
extract_mangle(head)
union record *head;
{
	char *buf;
	char *fromtape;
	char *to;
	char *ptr,*ptrend;
	char *nam1,*nam1end;
	int size;
	int copied;

	size=hstat.st_size;
	buf=to=ck_malloc(size+1);
	buf[size]='\0';
	while(size>0) {
		fromtape=findrec()->charptr;
		if(fromtape==0) {
			msg("Unexpected EOF in mangled names!");
			return;
		}
		copied=endofrecs()->charptr-fromtape;
		if(copied>size)
			copied=size;
		bcopy(fromtape,to,copied);
		to+=copied;
		size-=copied;
		userec((union record *)(fromtape+copied-1));
	}
	for(ptr=buf;*ptr;ptr=ptrend) {
		ptrend=index(ptr,'\n');
		*ptrend++='\0';

		if(!strncmp(ptr,"Rename ",7)) {
			nam1=ptr+7;
			nam1end=index(nam1,' ');
			while(strncmp(nam1end," to ",4)) {
				nam1end++;
				nam1end=index(nam1end,' ');
			}
			*nam1end='\0';
			if(ptrend[-2]=='/')
				ptrend[-2]='\0';
			un_quote_string(nam1end+4);
			if(rename(nam1,nam1end+4))
				msg_perror("Can't rename %s to %s",nam1,nam1end+4);
			else if(f_verbose)
				msg("Renamed %s to %s",nam1,nam1end+4);
		}
#ifdef S_ISLNK
		else if(!strncmp(ptr,"Symlink ",8)) {
			nam1=ptr+8;
			nam1end=index(nam1,' ');
			while(strncmp(nam1end," to ",4)) {
				nam1end++;
				nam1end=index(nam1end,' ');
			}
			*nam1end = '\0';
			un_quote_string(nam1);
			un_quote_string(nam1end+4);
			if(symlink(nam1,nam1end+4) && (unlink(nam1end+4) || symlink(nam1,nam1end+4)))
				msg_perror("Can't symlink %s to %s",nam1,nam1end+4);
			else if(f_verbose)
				msg("Symlinkd %s to %s",nam1,nam1end+4);
		}
#endif
		else
			msg("Unknown demangling command %s",ptr);
	}
}