fileiomac.cc #1

/*
 * Copyright 1995, 1996 Perforce Software.  All rights reserved.
 *
 * This file is part of Perforce - the FAST SCM System.
 */

# define NEED_STAT

# include <stdhdrs.h>

# if defined ( OS_MACOSX )


# include <error.h>
# include <errornum.h>
# include <msgos.h>
# include <strbuf.h>
# include <strarray.h>

# include <i18napi.h>
# include <charcvt.h>

# include "filesys.h"
# include "fileio.h"

# include "macfile.h"

static const OSType kUnknownSignature = FOUR_CHAR_CONSTANT('?','?','?','?');

extern int global_umask;

FileIOMac::FileIOMac()
{
	mf = 0;
}

FileIOMac::~FileIOMac()
{
	delete mf;
}

void
FileIOMac::Set( const StrPtr &name )
{
	Set( name, 0 );
}

void
FileIOMac::Set( const StrPtr &name, Error *e )
{
	//
	// The MacFile will no longer refer to this new name,
	// so delete it.
	//
	delete mf;
	mf = 0;
	FileSys::Set( name, e );
}

MacFile * FileIOMac::GetMacFile( Error *e )
{
	OSErr err;
	
	if ( !mf )
	{
	    MacFile * macFile = MacFile::GetFromPath(
	                        Name(),
	                        &err);

	    if ( !macFile )
	    {
		if ( e ) e->Sys("open", Name() );
		return NULL;
	    }
	    
	    mf = macFile;
	}
	
	return mf;
}


MacFile * FileIOMac::CreateMacFile( Error *e )
{
	OSErr err;
	
	if ( !mf )
	{
	    MacFile * tempMf = MacFile::CreateFromPath(
	                        Name(),
	                        false,
	                        &err);

	    if ( !tempMf )
	    {
		if ( e ) e->Sys("open", Name() );
		return NULL;
	    }
	    
	    mf = tempMf;
	}
	
	return mf;
}


void
FileIOMac::Open( FileOpenMode mode, Error *e )
{
	// Save mode for write, close

	this->mode = mode;

	// Short circuit stdio

	if( Name()[0] == '-' && !Name()[1] )
	    return;

	int perm = mode == FOM_WRITE ? fsWrPerm : fsRdPerm;

	// Get handles for real file 
    
	MacFile * macFile = GetMacFile( e );
	
	if ( perm == fsWrPerm )
	{
	    if ( !macFile )
	    {
		e->Clear();
		macFile = CreateMacFile( e );
	    }
	}
	
	if ( macFile )
	{
     
	    if( macFile->OpenDataFork( perm ) != noErr )
	    {
		e->Sys("open", Name() );
		return;
	    }
	}
}

void
FileIOMac::Close( Error *e )
{
	if( !mf )
	    return;
    
	if( (mf)->CloseDataFork() < 0 )
	    e->Sys( "close", Name() );	

	if( mode == FOM_WRITE && modTime )
	    ChmodTime( modTime, e );

	if( mode == FOM_WRITE )
	    Chmod( perms, e );
        
        // This needs to happen only on Mac OS 10.0.0.x
        // versions of the OS. The FSRef (inside MacFile) will
        // be maintained through another app editing it on Mac OS 10.1
        //
        delete mf;
        mf = NULL;
}

int
FileIOMac::Read( char *buf, int len, Error *e )
{
	// Short circuit stdio

	if( Name()[0] == '-' && !Name()[1] )
	{
	    return fread( buf, 1, len, stdin );
	}

	ByteCount size = len;
    
	OSErr err = mf->ReadDataFork( size, buf, &size );

	if ( err == noErr || err == eofErr )
	    return size;

	e->Sys( "read", Name() );
	return -1;
}

void
FileIOMac::Write( const char *buf, int len, Error *e )
{
	// Short circuit stdio

	if( Name()[0] == '-' && !Name()[1] )
	{
	    fwrite( buf, 1, len, stdout );
	    return;
	}

	ByteCount size = len;
	
	if ( mf )
	{
	    if ( mf->WriteDataFork( size, buf, &size ) != noErr )
	    e->Sys( "write", Name() );
	}
}

offL_t
FileIOMac::GetSize()
{
	if ( mf )
	{
	    return mf->GetDataForkSize();
	}
	else
	    return 0;
}

void
FileIOMac::Seek( offL_t offset, Error * )
{
	if ( mf )
	{
	    mf->SetDataForkPosition( offset );
	}
}


/*
 * FileIOMac::Stat() -- workaround broken CW stat()
 */

int
FileIOMac::Stat( bool includeRsrcFork )
{
	int flags = 0;

	flags = FileIO::Stat();
	
	if ( !includeRsrcFork )
	    return flags;

	if ( !(flags & FSF_EXISTS) )
	    return flags;

	if ( flags & FSF_DIRECTORY )
	    return flags;

	if ( flags & FSF_SYMLINK )
	    return flags;

	if ( !(flags & FSF_EMPTY) )
	    return flags;

	// If the file is empty, double-check for the resource fork
	//
	Error e;
	const MacFile * fileEntity = GetMacFile( &e );

	if( fileEntity && fileEntity->GetResourceForkSize() > 0 )
	    flags &= ~FSF_EMPTY;

	return flags;
}

void
FileIOMac::Rename( FileSys *target, Error *e )
{
	// copy, rather than rename, to preserve any data/resource fork
	
	if ( ( target->GetType() & FST_MASK ) != FST_SYMLINK )
	{
	    // make target writeable first

	    Chmod( FPM_RW, e );

	    if( e->Test() )
	    {
		e->Clear();

		// raw chmod failed... try unlink...
		// This is pretty safe I think because
		// if the unlink succeeds then we know we can write
		// the directory so create the file with the copy
		// below.  If the unlink fails, we give up because
		// we will not be able to write the resource fork
		// or some other problem will happen...

		if( target->Stat() & FSF_EXISTS )
		{
		    target->Unlink( e );
		    if( e->Test() )
			return;
		    target->ClearDeleteOnClose();
		}
	    }

	    Copy( target, FPM_RW, e );

	    if( e->Test() )
		return;

	    Unlink( e );

	    // reset the target to our perms

	    target->Perms( perms );
	    target->Chmod( e );
	}
	else if( rename( Name(), target->Name() ) < 0 )
	{
	    e->Sys( "rename", target->Name() );
	    return;
	}

	// source file has been deleted,  clear the flag

	ClearDeleteOnClose();
}
 
/*
 * FileIOMac::Unlink() - remove apple file
 *
 * This is special because it will cleanup resource fork
 * hidden files which mess up Rename via Copy.
 */

void
FileIOMac::Unlink( Error *e )
{
	if( !*Name() )
	    return;

	Chmod( FPM_RW, 0 );

	MacFile *macFile = GetMacFile( e );

	if( ( !macFile || macFile->Delete() != noErr ) && e )
	    e->Sys( "unlink", Name() );
}

/*
 * FileIOResource support
 */
 
FileIOResource::FileIOResource()
{
	resourceData = 0;
}

FileIOResource::~FileIOResource()
{
	Cleanup();
}

# if defined ( OS_MACOSX )

/*
 * MAC FileSys::Set() - set file name, recognizing .file as resource
 */

void
FileIOResource::Set( const StrPtr &name )
{
	Set( name, 0 );
}
void
FileIOResource::Set( const StrPtr &name, Error *e )
{
	// Set colon to file component (after final :)
	const char *colon = NULL;
	colon = strrchr( name.Text(), GetSystemFileSeparator() ); // unix paths
	colon = colon ? colon + 1 : name.Text();
	hasDotInName = *colon == '.';

	// Is this a .file ?
	// If so, note that the name indicates a resource fork.
	// It is really if resource fork if SetType is told so,
	// but we use this information to cue CheckType().

	if( hasDotInName )
	{
	    // Name sans dot
	    path.Set( name.Text(), colon - name.Text() );
	    path.Append( colon + 1 );
	}
	else
	{
	    // No.  Plain file.
	    path.Set( name );
	}
}

# else

void
FileIOResource::Set( const StrPtr &name )
{
	Set( name, 0 );
}
void
FileIOResource::Set( const StrPtr &name, Error *e )
{
	path.Set( name );
}

# endif


void
FileIOResource::Open( FileOpenMode mode, Error *e )
{
	// Save mode for write, close

	this->mode = mode;

	resourceData = new StrBuf;

	// If we're opening the resource fork for read, fill temp file and
	// open that.
	
	if( mode == FOM_READ )
	{

	    ByteCount size;		// bytes to write to file
	    char *buf;
            OSErr err;

	    ioOffset = 0;
	    resourceData->Clear();

	    MacFile * macFile = MacFile::GetFromPath(
	                        Name(),
	                        &err );

	    if ( !macFile )
	    {
		e->Sys( "File not found for resource encoding!", Name() );
		return;
	    }

	    if( macFile->OpenResourceFork( fsRdPerm ) != noErr )
	    {
		e->Sys("Can't open resource fork for encoding!", Name() );
    		delete macFile;
		return;
	    }

	    /*
	     * Put file info into resource fork.
	     */

	    size = sizeof( FInfo );
	    buf = resourceData->Alloc( size );
	    const FInfo *fi = macFile->GetFInfo();
	    memcpy( buf, fi, size );
	    MacFile::SwapFInfo( (FInfo *)buf );

	    size = macFile->GetResourceForkSize();
	    buf = resourceData->Alloc( size );
        
	    if( macFile->ReadResourceFork( size, buf, &size ) != noErr )
	    {
    		e->Sys( "Error reading from resource fork!", Name());
	    }
	    
            macFile->CloseResourceFork();
    	
    	    delete macFile;
        
	}
}

void
FileIOResource::Write( const char *buf, int len, Error *e )
{
	resourceData->Append( buf, len );
}

int
FileIOResource::Read( char *buf, int len, Error *e )
{
	int l = resourceData->Length() - ioOffset;

	if( len < l )
	    l = len;

	memcpy( buf, resourceData->Text() + ioOffset, l );

	ioOffset += l;

	return l;
}

void
FileIOResource::Close( Error *e )
{
	if( !resourceData )
	    return;

	if( mode == FOM_WRITE )
	{
	    ByteCount size;		// bytes to read from file
	    
	    char *buf = resourceData->Text();

	    if( resourceData->Length() < sizeof( FInfo ) )
	    {
		e->Set( MsgOs::EmptyFork ) << Name();
		return;
	    }

	    OSErr err;
	    
            MacFile * macFile =  MacFile::GetFromPath(
	                                Name(),
	                                &err );
	    if ( !macFile )
	    {
		macFile = MacFile::CreateFromPath(
	                Name(),
	                false,
	                &err );
	    }

	    if ( !macFile )
	    {
		e->Sys("open", Name() );
		return;
	    }

	    if ( macFile->IsDir() )
	    {
		e->Sys( "File not found for resource encoding!", Name() );
		return;
	    }
	    
	    if( macFile->OpenResourceFork( fsWrPerm ) != noErr )
	    {
		e->Sys( "Can't open resource fork of file %s.", Name() );
    		delete macFile;
    		return;
	    }

	    FInfo info;
	    size = sizeof(FInfo);
	    memcpy( &info, buf, size );
	    MacFile::SwapFInfo( &info );
	    buf += size;

	    // Write contents of resource fork.
	    // Truncate it, too, because Mac is special.

	    size = resourceData->Length() - sizeof( FInfo );

	    if ( macFile->WriteResourceFork( size, buf, &size ) != noErr )
		    e->Sys( "Error writing resource fork of %s.", Name() );
		
	    if ( macFile->CloseResourceFork() != noErr )
		    e->Sys( "Error closing resource fork of %s.", Name() );

	    // save FileInfo & close off file

	    if ( macFile->SetFInfo( &info ) != noErr )
		    e->Sys( "Error writing Finder Info of %s.", Name() );
	    
	    // Set readonly/rw as necessary
	    
	    Chmod( perms, e );
	    
	    delete macFile;

	}

	delete resourceData;
	resourceData = 0;
}

void
FileIOResource::Unlink( Error *e )
{
	// do nothing for the resource fork.
}

# endif /* OS_MACOSX */