if (fd == STDERR_HANDLE && stderr_fd != STDERR_HANDLE)
		fd = stderr_fd;
	
    if (  fd == STDOUT_HANDLE 
       || fd == STDERR_HANDLE 
       ) {
        int i;
        for (i=0; i<n; i++) {
            if (buf[i] == 0x0a) buf[i]= 0x0d;
        }
    }
    
    return write(fd,buf,n);
}


static int my_open_dll( char *name )
{
    return OpenDll_open_dll(name, (RPCServ_OpenFunc) open, object_endian);
}

Boolean StartTM(Int32 node)
{
#ifdef DEBUG
	printf("Starting node %d\n", node);
#endif

    if (!CommBufferClean) {
	  _HostCall_commvar[0]= 0;
	  _HostCall_commvar[1]= 0;
	  _HostCall_commvar[2]= 0;
	  _HostCall_commvar[3]= 0;
      CommBufferClean = True;
    }
    
    // strange?
    MMIO_M(node,BIU_CTL) |= SET_RST_MASK;
    MMIO_M(node,BIU_CTL) &= ~SET_RST_MASK;
        
    // This takes TM out of reset
    MMIO_M(node,BIU_CTL) |= CLEAR_RST_MASK;
    
    MMIO_M(node,SEM) = 0;
    
    TMInfo[node].TM_running = true;
    
    return true;
}

void StartTMHostComm(void)
{

    CommBufferClean = False;
    TM1IF_start_serving();
}

OSStatus GetRevisionID(const RegEntryID *theEntry, UInt32* revision_id);
OSStatus GetRevisionID(const RegEntryID *theEntry, UInt32* revision_id)
{
	OSStatus 				err;
	RegPropertyValueSize	SizeOfProp;
	void			 		*propValue;
	
	err = RegistryPropertyGetSize(theEntry, "revision-id", &SizeOfProp);							/* need node's reg property size */
	if (err == noErr)
	{		
		propValue = NULL;																	/* allocate space for a local variable */
		propValue = NewPtr(SizeOfProp);														/* in Memory.h */
		if (propValue == NULL)
		{
			printf("\nERROR: No memory available to store property value.\n");
			return -1;
		}
		err = RegistryPropertyGet(theEntry, "revision-id", propValue, &SizeOfProp);		/* get the name value */
		if (err != noErr)
			return err;
//		printf("0x%x\n", * (UInt32*) propValue);	
		*revision_id = *(UInt32*)propValue;	
		
	}	
	return err;
}

//===================================================================
//===================================================================
OSStatus
GetDeviceProperty( RegEntryID *pRegID, RegPropertyName *pPropertyName, 
					RegPropertyValue *pPropertyValue, RegPropertyValueSize *pPropertySize );
OSStatus
GetDeviceProperty( RegEntryID *pRegID, RegPropertyName *pPropertyName, 
					RegPropertyValue *pPropertyValue, RegPropertyValueSize *pPropertySize )
{ 
	OSStatus	err = noErr;
	
	/*
	 * Get the size of the value first to see if our buffer is big enough.
	 */
	err = RegistryPropertyGetSize( pRegID, pPropertyName, pPropertySize );
	if ( err == noErr )
	{
		*pPropertyValue = (RegPropertyValue) malloc( *pPropertySize );
		/*
		 * Note, we return the actual property size.
		 */
		err = RegistryPropertyGet( pRegID, pPropertyName, *pPropertyValue, pPropertySize );
	}
	
	return err;
}

//===================================================================
//===================================================================
OSStatus
DisposeProperty( RegPropertyValue propertyValue );
OSStatus
DisposeProperty( RegPropertyValue propertyValue )
{
	if (propertyValue)
		free( propertyValue );
	return noErr;
}

//===================================================================
//===================================================================
OSStatus
GetBaseAddress( RegEntryID *pRegID, UInt32 *pBaseRegAddress,
				UInt8 offsetValue, UInt32 *pSpaceAllocated );
OSStatus
GetBaseAddress( RegEntryID *pRegID, UInt32 *pBaseRegAddress,
				UInt8 offsetValue, UInt32 *pSpaceAllocated )
{
	OSStatus				osStatus;
	PCIAssignedAddress		*pAssignedArray;
	RegPropertyValueSize	propertySize;
	UInt32					numberOfElements, *pVirtualArray;
	Boolean					foundMatch;
	UInt16					index;
		
	*pBaseRegAddress = NULL; // default value
	foundMatch = false;
	
	osStatus = GetDeviceProperty( pRegID, kPCIAssignedAddressProperty,
										&pAssignedArray, &propertySize);

	if ( (osStatus == noErr) && propertySize )
	{
		numberOfElements = propertySize/sizeof(PCIAssignedAddress);
		
		osStatus = GetDeviceProperty( pRegID, kAAPLDeviceLogicalAddress,
											&pVirtualArray, &propertySize);

		if ( (osStatus == noErr) && propertySize )
		{
			// search through the assigned addresses property looking for base register
			for (index = 0; (index != numberOfElements) && !foundMatch; ++index)
			{
				if (pAssignedArray[index].registerNumber == offsetValue)
				{
					if ( pSpaceAllocated )
						*pSpaceAllocated = pAssignedArray[index].size.lo;
					if ( pBaseRegAddress ) {
						if ( pVirtualArray[index] == nil ) {
							*pBaseRegAddress = pAssignedArray[index].address.lo;
						} else {
							*pBaseRegAddress = pVirtualArray[index];
						}
					}
					foundMatch = true;
				}
			}
		
			DisposeProperty( pVirtualArray );
		}
		else
			if ( osStatus != noErr )
				osStatus = nrInvalidNodeErr;
	
		DisposeProperty( pAssignedArray );
	}
	else
		if ( osStatus != noErr )
			osStatus = nrInvalidNodeErr;
		
	return osStatus;
}

// ------------------------------------------------
// FindPropertyWithValue
// 	Find a node with a specific property and value in the Registry
// jdb: propertyNamePtr is the string to match
//		propertyValue is the value of the property
//		foundEntry is the returned node id.
//		returns:	1.  noErr if foundEntry is updated
//				2.  done if done is true (got to end of device tree and didn't find property)
//			      	3.  an error if Registry routines return an error.
// ------------------------------------------------

OSStatus FindPropertyWithValue(const RegPropertyName *propertyName, const void *propertyValue, 
                               const RegPropertyValueSize propertySize, RegEntryID *foundEntry);
OSStatus FindPropertyWithValue(const RegPropertyName *propertyName, const void *propertyValue, 
                               const RegPropertyValueSize propertySize, RegEntryID *foundEntry)
{
	RegEntryIter 		cookie; 
	RegEntryID 		theEntry; 
	RegEntryIterationOp 	iterOp; 
	Boolean 		done; 
	OSStatus 		err = noErr;

	RegistryEntryIDInit(&theEntry);

	err = RegistryEntryIterateCreate(&cookie); 
	if (err != noErr) 
		return err;

	iterOp = kRegIterContinue; 

	err = RegistryEntrySearch(&cookie, iterOp, &theEntry, &done, 
				  propertyName, propertyValue, propertySize);

	if (!done && (err == noErr)) 
	{ 
		*foundEntry = theEntry; 
	}
	else if (done) 
		err = done; 

	RegistryEntryIDDispose(&theEntry); 
	RegistryEntryIterateDispose(&cookie);
	 
	return err; 
}

/* Slight misnomer since GetTMPreferences() also creates one if it's missing. */

Boolean GetTMPreference(const char * name, char * value) 
{
  OSErr err;
  short myVRef;
  FSSpec mySpec;
  char* myBuffer ;
  short myRefNum, myVol;
  long int myDirID;
  long int myLength = strlen((const char*) PREFERENCES);
  long int i,j, k;
  int found = false;
  int length;
    
  if (name == NULL || value == NULL) return false;
  
  err = FindFolder(kOnSystemDisk, kPreferencesFolderType, kCreateFolder, &myVRef, &myDirID);
  if(err != noErr) {
    printf("Cannot find preference folder (%d)\n", err);
    return false;
  }
  
  err = FSMakeFSSpec(myVRef, myDirID, P_PREFERENCE_FILE, &mySpec);
  if(err == fnfErr) {
    /* file not found, so generate one */
    err = FSpCreate(&mySpec, 'ttxt', 'TEXT', smSystemScript);
    if(err != noErr) {
      printf("Cannot create preference file %s (%d)\n", C_PREFERENCE_FILE, err);
      return false;
    }
    err = FSpOpenDF(&mySpec, fsRdWrPerm, &myRefNum);
    if(err != noErr) {
      printf("Cannot open preference file %s after creation (%d)\n", C_PREFERENCE_FILE, err);
      return false;
    }
    err = SetFPos(myRefNum, fsFromStart, 0);
    if(err != noErr) {
      printf("Cannot set position in preference file %s (%d)\n", C_PREFERENCE_FILE, err);
      return false;
    }
    err = FSWrite(myRefNum, &myLength, PREFERENCES);
    if(err != noErr) {
      printf("Cannot write to preference file %s (%d)\n", C_PREFERENCE_FILE, err);
      return false;
    }
    err = SetEOF(myRefNum, myLength);
    if(err != noErr) {
      printf("Cannot set EOF in preference file %s (%d)\n", C_PREFERENCE_FILE, err);
      return false;
    }
    err = GetVRefNum(myRefNum, &myVol);
    if(err != noErr) {
      printf("Cannot get volume of preference file %s (%d)\n", C_PREFERENCE_FILE, err);
      return false;
    }
    err = FlushVol(Null, myVol);
    if(err != noErr) {
      printf("Cannot flush preference file %s (%d)\n", C_PREFERENCE_FILE, err);
      return false;
    }
    err = FSClose(myRefNum);  
    if(err != noErr) {
      printf("Cannot close preference file %s (%d)\n", C_PREFERENCE_FILE, err);
    }
    printf("Created default '" C_PREFERENCE_FILE "' file in the Preferences folder.\n");
  }
  else if (err != noErr) {
    printf("Cannot find preference file %s or something (%d)\n", C_PREFERENCE_FILE, err);
    return false;
  }

  err = FSpOpenDF(&mySpec, fsCurPerm, &myRefNum);
  if(err != noErr) {
    printf("Cannot find preference file %s or something (%d)\n", C_PREFERENCE_FILE, err);
    return false;
  }
  err = GetEOF(myRefNum, &myLength);
  if(err != noErr) {
    printf("Cannot get length of preference file %s (%d)\n", C_PREFERENCE_FILE, err);
    return false;
  }
  
  myBuffer =  (char*) NewPtr(myLength);
  if(myBuffer == NULL) {
    printf("Cannot allocate enough memory\n");
    return false;
  }
  err = FSRead(myRefNum, &myLength, myBuffer);
  if(err != noErr) {
    printf("Cannot read preference file %s (%d)\n", C_PREFERENCE_FILE, err);
    return false;
  }
  
  i = 0;
  length = strlen(name); 

  while (i < myLength) {
    /* check whether we see the correct attribute */
    if (strncmp(name, myBuffer+i, length) == 0) {
       /* check whether we see a '=' now */
       if (myBuffer[i + length] == '=') {
         /* set the cursor j just after the '=' */
         j = i + length + 1;
         k = 0;
         found = true;
         /* and copy everything until newline (in MPW/Mac way) or end of file */
         while (myBuffer[j] != '\n' && myBuffer[j] != '\r' && j < myLength) 
           value[k++] = myBuffer[j++];
         value[k] = '\0';
         /* break out the while */
         break;
       }
       /* else printf("almost\n"); */
    }
    i++;
  }  
  
  err = FSClose(myRefNum);  
  if(err != noErr) {
    printf("Cannot close preference file %s (%d)\n", C_PREFERENCE_FILE, err);
  }

  return found;
}

int
GetTMExitStatus(Int32 node)
{
   return TMInfo[node].Exit_Status;
}

Boolean 
TMQuit(void)
{
    return FreeSharedHostMemory(_HostCall_commvar);
}

Boolean
AllocateSharedHostMemory (int nbytes, void** pp_lin_mem, unsigned long* pl_ph_mem)
{
 	int i;
	OSStatus err = 0;
    LogicalAddress logical_mapping[2];
    PhysicalAddress physical_mapping[2];
    IOPreparationTable IOTable;

	*pp_lin_mem = NULL;
	*pl_ph_mem  = NULL;

	*pp_lin_mem =  (void *)MemAllocatePhysicallyContiguous(nbytes,true);
	
	if (!*pp_lin_mem)
	{
      printf("AllocateSharedHostMemory: MemAllocatePhysicallyContiguous failed\n");
	  return false;
	}
	
	IOTable.options = (kIOMinimalLogicalMapping | kIOLogicalRanges | kIOIsInput);
	IOTable.state = 0;
	IOTable.addressSpace = kCurrentAddressSpaceID;