diff -uNr fontconfig-2.3.2/src/Makefile.am fontconfig-2.3.2-new/src/Makefile.am
--- fontconfig-2.3.2/src/Makefile.am	2004-12-05 00:49:20.000000000 -0500
+++ fontconfig-2.3.2-new/src/Makefile.am	2006-08-05 19:47:47.000000000 -0400
@@ -86,6 +86,7 @@
 	fcdefault.c \
 	fcdir.c \
 	fcfreetype.c \
+	fcftglue.c \
 	fcfs.c \
 	fcinit.c \
 	fclang.c \
diff -uNr fontconfig-2.3.2/src/Makefile.in fontconfig-2.3.2-new/src/Makefile.in
--- fontconfig-2.3.2/src/Makefile.in	2005-04-27 15:08:51.000000000 -0400
+++ fontconfig-2.3.2-new/src/Makefile.in	2006-08-05 19:47:47.000000000 -0400
@@ -228,6 +228,7 @@
 	fcdefault.c \
 	fcdir.c \
 	fcfreetype.c \
+	fcftglue.c \
 	fcfs.c \
 	fcinit.c \
 	fclang.c \
@@ -257,7 +258,7 @@
 libfontconfig_la_DEPENDENCIES =
 am_libfontconfig_la_OBJECTS = fcatomic.lo fcblanks.lo fccache.lo \
 	fccfg.lo fccharset.lo fcdbg.lo fcdefault.lo fcdir.lo \
-	fcfreetype.lo fcfs.lo fcinit.lo fclang.lo fclist.lo fcmatch.lo \
+	fcfreetype.lo fcftglue.lo fcfs.lo fcinit.lo fclang.lo fclist.lo fcmatch.lo \
 	fcmatrix.lo fcname.lo fcpat.lo fcstr.lo fcxml.lo
 libfontconfig_la_OBJECTS = $(am_libfontconfig_la_OBJECTS)
 
diff -uNr fontconfig-2.3.2/src/fcfreetype.c fontconfig-2.3.2-new/src/fcfreetype.c
--- fontconfig-2.3.2/src/fcfreetype.c	2005-04-21 08:37:43.000000000 -0400
+++ fontconfig-2.3.2-new/src/fcfreetype.c	2006-08-05 19:47:47.000000000 -0400
@@ -50,14 +50,11 @@
 #include "fcint.h"
 #include <ft2build.h>
 #include FT_FREETYPE_H
-#include FT_INTERNAL_OBJECTS_H
 #include FT_TRUETYPE_TABLES_H
 #include FT_SFNT_NAMES_H
 #include FT_TRUETYPE_IDS_H
 #include FT_TYPE1_TABLES_H
-#include FT_INTERNAL_STREAM_H
-#include FT_INTERNAL_SFNT_H
-#include FT_INTERNAL_TRUETYPE_TYPES_H
+#include "fcftglue.h"
 #if HAVE_FT_GET_X11_FONT_FORMAT
 #include FT_XFREE86_H
 #endif
@@ -65,8 +62,7 @@
 #if HAVE_FT_GET_BDF_PROPERTY
 #include FT_BDF_H
 #include FT_MODULE_H
-#define HAS_BDF_PROPERTY(f) ((f) && (f)->driver && \
-			     (f)->driver->root.clazz->get_interface)
+#define HAS_BDF_PROPERTY(f) ((f))
 #define MY_Get_BDF_Property(f,n,p) (HAS_BDF_PROPERTY(f) ? \
 				    FT_Get_BDF_Property(f,n,p) : \
 				    FT_Err_Invalid_Argument)
@@ -1559,7 +1555,7 @@
      */
     if (FcCharSetCount (cs) == 0)
     {
-	if (!strcmp(FT_MODULE_CLASS(&face->driver->root)->module_name, "pcf"))
+	if (!strcmp(FT_Get_X11_Font_Format(face),"PCF"))
 	    goto bail2;
     }
 
@@ -2706,8 +2702,7 @@
 static FT_Error
 GetScriptTags(FT_Face face, FT_ULong tabletag, FT_ULong **stags, FT_UShort *script_count)
 {
-    FT_ULong         cur_offset, new_offset, base_offset;
-    TT_Face          tt_face = (TT_Face)face;
+    FT_ULong   cur_offset, new_offset, base_offset;
     FT_Stream  stream = face->stream;
     FT_Error   error;
     FT_UShort          n, p;
@@ -2716,51 +2711,43 @@
     if ( !stream )
 	return TT_Err_Invalid_Face_Handle;
 
-    if (( error = tt_face->goto_table( tt_face, tabletag, stream, 0 ) ))
+    if ( (error = fcft_face_goto_table( face, tabletag, stream )) != 0 )
 	return error;
 
-    base_offset = FT_STREAM_POS();
+    base_offset = FCFT_STREAM_POS();
 
     /* skip version */
 
-    if ( FT_STREAM_SEEK( base_offset + 4L ) || FT_FRAME_ENTER( 2L ) )
-	return error;
-
-    new_offset = FT_GET_USHORT() + base_offset;
-
-    FT_FRAME_EXIT();
-
-    cur_offset = FT_STREAM_POS();
-
-    if ( FT_STREAM_SEEK( new_offset ) != TT_Err_Ok )
-	return error;
-
-    base_offset = FT_STREAM_POS();
+    if ( FCFT_STREAM_SEEK( base_offset + 4L ) ||
+         FCFT_READ_USHORT( new_offset )       ) 
+      return error;
+    
+    new_offset += base_offset;
+    cur_offset  = FCFT_STREAM_POS();
 
-    if ( FT_FRAME_ENTER( 2L ) )
+    if ( FCFT_STREAM_SEEK( new_offset ) != TT_Err_Ok )
 	return error;
 
-    *script_count = FT_GET_USHORT();
+    base_offset = FCFT_STREAM_POS();
 
-    FT_FRAME_EXIT();
-
-    if ( FT_SET_ERROR (FT_MEM_ALLOC_ARRAY( *stags, *script_count, FT_ULong )) )
-	return error;
+    if ( FCFT_READ_USHORT(*script_count)                         ||
+         FCFT_MEM_ALLOC_ARRAY( *stags, *script_count, FT_ULong ) )
+ 	return error;
 
     p = 0;
     for ( n = 0; n < *script_count; n++ )
     {
-	if ( FT_FRAME_ENTER( 6L ) )
+	if ( FCFT_FRAME_ENTER( 6L ) )
 	    goto Fail;
 
-	(*stags)[p] = FT_GET_ULONG();
-	new_offset = FT_GET_USHORT() + base_offset;
+	(*stags)[p] = FCFT_GET_ULONG();
+	new_offset  = FCFT_GET_USHORT() + base_offset;
 
-	FT_FRAME_EXIT();
+	FCFT_FRAME_EXIT();
 
-	cur_offset = FT_STREAM_POS();
+	cur_offset = FCFT_STREAM_POS();
 
-	if ( FT_STREAM_SEEK( new_offset ) )
+	if ( FCFT_STREAM_SEEK( new_offset ) )
 	    goto Fail;
 
 	if ( error == TT_Err_Ok )
@@ -2768,7 +2755,7 @@
 	else if ( error != TTO_Err_Empty_Script )
 	    goto Fail;
 
-	(void)FT_STREAM_SEEK( cur_offset );
+	(void)FCFT_STREAM_SEEK( cur_offset );
     }
 
     if (!p)
@@ -2784,7 +2771,7 @@
 
 Fail:
     *script_count = 0;
-    FT_FREE( *stags );
+    FCFT_FREE( *stags );
     return error;
 }
 
@@ -2841,7 +2828,7 @@
     if (FcDebug () & FC_DBG_SCANV)
 	printf("complex features in this font: %s\n", complex);
 bail:
-    FT_FREE(gsubtags);
-    FT_FREE(gpostags);
+    FCFT_FREE(gsubtags);
+    FCFT_FREE(gpostags);
     return complex;
 }
diff -uNr fontconfig-2.3.2/src/fcftglue.c fontconfig-2.3.2-new/src/fcftglue.c
--- fontconfig-2.3.2/src/fcftglue.c	1969-12-31 19:00:00.000000000 -0500
+++ fontconfig-2.3.2-new/src/fcftglue.c	2006-08-05 19:47:47.000000000 -0400
@@ -0,0 +1,380 @@
+#include "fcftglue.h"
+
+/***************************************************************************/
+/***************************************************************************/
+/*****                                                                 *****/
+/*****                                                                 *****/
+/*****                                                                 *****/
+/***************************************************************************/
+/***************************************************************************/
+
+/* only used internall */
+static FT_Pointer
+fcft_qalloc( FT_Memory  memory,
+             FT_ULong   size,
+             FT_Error  *perror )
+{
+  FT_Error    error = 0;
+  FT_Pointer  block = NULL;
+
+  if ( size > 0 )
+  {
+    block = memory->alloc( memory, size );
+    if ( !block )
+      error = FT_Err_Out_Of_Memory;
+  }
+
+  *perror = error;
+  return block;
+}
+
+#define  FCFT_QALLOC(ptr,size)    ( (ptr) = fcft_qalloc( memory, (size), &error ), error != 0 )
+
+
+FCFT_APIDEF( FT_Pointer )
+fcft_alloc( FT_Memory  memory,
+            FT_ULong   size,
+            FT_Error  *perror )
+{
+  FT_Error    error = 0;
+  FT_Pointer  block = NULL;
+
+  if ( size > 0 )
+  {
+    block = memory->alloc( memory, size );
+    if ( !block )
+      error = FT_Err_Out_Of_Memory;
+    else
+      memset( (char*)block, 0, (size_t)size );
+  }
+
+  *perror = error;
+  return block;
+}
+
+
+FCFT_APIDEF( FT_Pointer )
+fcft_realloc( FT_Memory   memory,
+              FT_Pointer  block,
+              FT_ULong    old_size,
+              FT_ULong    new_size,
+              FT_Error   *perror )
+{
+  FT_Pointer  block2 = NULL;
+  FT_Error    error  = 0;
+
+  if ( block == NULL )
+  {
+    block2 = fcft_alloc( memory, new_size, &error );
+  }
+  else if ( new_size <= 0 )
+  {
+    fcft_free( memory, block );
+  }
+  else
+  {
+    block2 = fcft_alloc( memory, new_size, &error );
+    if ( !error )
+    {
+      memcpy( (char*)block2, (const char*)block, (size_t)old_size );
+      if ( new_size > old_size )
+        memset( (char*)block2 + old_size, 0, (size_t)(new_size - old_size) );
+    }
+  }
+
+  if ( !error )
+    block = block2;
+
+  *perror = error;
+  return block;
+}
+
+
+FCFT_APIDEF( void )
+fcft_free( FT_Memory   memory,
+           FT_Pointer  block )
+{
+  if ( block )
+    memory->free( memory, block );
+}
+
+
+FCFT_APIDEF( FT_Long )
+fcft_stream_pos( FT_Stream   stream )
+{
+  return stream->pos;
+}
+
+
+FCFT_APIDEF( FT_Error )
+fcft_stream_seek( FT_Stream   stream,
+                  FT_Long     pos )
+{
+  FT_Error  error = 0;
+
+  stream->pos = pos;
+  if ( stream->read )
+  {
+    if ( stream->read( stream, pos, 0, 0 ) )
+      error = FT_Err_Invalid_Stream_Operation;
+  }
+  else if ( pos > stream->size )
+    error = FT_Err_Invalid_Stream_Operation;
+
+  return error;
+}
+
+
+FCFT_APIDEF( FT_Error )
+fcft_stream_frame_enter( FT_Stream   stream,
+                         FT_ULong    count )
+{
+  FT_Error  error = FT_Err_Ok;
+  FT_ULong  read_bytes;
+
+  if ( stream->read )
+  {
+    /* allocate the frame in memory */
+    FT_Memory  memory = stream->memory;
+
+
+    if ( FCFT_QALLOC( stream->base, count ) )
+      goto Exit;
+
+    /* read it */
+    read_bytes = stream->read( stream, stream->pos,
+                               stream->base, count );
+    if ( read_bytes < count )
+    {
+      FCFT_FREE( stream->base );
+      error = FT_Err_Invalid_Stream_Operation;
+    }
+    stream->cursor = stream->base;
+    stream->limit  = stream->cursor + count;
+    stream->pos   += read_bytes;
+  }
+  else
+  {
+    /* check current and new position */
+    if ( stream->pos >= stream->size        ||
+         stream->pos + count > stream->size )
+    {
+      error = FT_Err_Invalid_Stream_Operation;
+      goto Exit;
+    }
+
+    /* set cursor */
+    stream->cursor = stream->base + stream->pos;
+    stream->limit  = stream->cursor + count;
+    stream->pos   += count;
+  }
+
+Exit:
+  return error;
+}
+
+
+FCFT_APIDEF( void )
+fcft_stream_frame_exit( FT_Stream  stream )
+{
+  if ( stream->read )
+  {
+    FT_Memory  memory = stream->memory;
+
+    FCFT_FREE( stream->base );
+  }
+  stream->cursor = 0;
+  stream->limit  = 0;
+}
+
+
+FCFT_APIDEF( FT_Byte )
+fcft_stream_get_byte( FT_Stream  stream )
+{
+  FT_Byte  result = 0;
+
+  if ( stream->cursor < stream->limit )
+    result = *stream->cursor++;
+
+  return result;
+}
+
+
+FCFT_APIDEF( FT_Short )
+fcft_stream_get_short( FT_Stream  stream )
+{
+  FT_Byte*  p;
+  FT_Short  result = 0;
+
+  p = stream->cursor;
+  if ( p + 2 <= stream->limit )
+  {
+    result         = (FT_Short)((p[0] << 8) | p[1]);
+    stream->cursor = p+2;
+  }
+  return result;
+}
+
+
+FCFT_APIDEF( FT_Long )
+fcft_stream_get_long( FT_Stream   stream )
+{
+  FT_Byte*  p;
+  FT_Long   result = 0;
+
+  p = stream->cursor;
+  if ( p + 4 <= stream->limit )
+  {
+    result         = (FT_Long)(((FT_Long)p[0] << 24) |
+                               ((FT_Long)p[1] << 16) |
+                               ((FT_Long)p[2] << 8)  |
+                                         p[3]        );
+    stream->cursor = p+4;
+  }
+  return result;
+}
+
+
+static FT_Error
+fcft_stream_readp( FT_Stream   stream,
+                   FT_Byte*   *pbuffer,
+                   FT_ULong    count )
+{
+  FT_Error  error = 0;
+
+  if ( stream->read )
+  {
+    FT_ULong  read_bytes = stream->read( stream, stream->pos, *pbuffer, count );
+
+    if ( read_bytes != count )
+      goto Fail;
+
+    stream->pos += count;
+  }
+  else
+  {
+    if ( stream->pos >= stream->size        ||
+         stream->pos + count > stream->size )
+      goto Fail;
+
+    *pbuffer     = stream->base + stream->pos;
+    stream->pos += count;
+  }
+
+Exit:
+  return error;
+
+Fail:
+  error = FT_Err_Invalid_Stream_Operation;
+  goto Exit;
+}
+
+
+FCFT_API( FT_Byte )
+fcft_stream_read_byte( FT_Stream   stream,
+                       FT_Error   *perror )
+{
+  FT_Byte   temp[1], *p = temp, result = 0;
+  FT_Error  error = fcft_stream_readp( stream, &p, 1 );
+
+  if ( !error )
+    result = *p;
+
+  return error;
+}
+
+FCFT_API( FT_Short )
+fcft_stream_read_short( FT_Stream  stream,
+                        FT_Error  *perror )
+{
+  FT_Byte   temp[2], *p = temp;
+  FT_Short  result = 0;
+  FT_Error  error  = fcft_stream_readp( stream, &p, 2 );
+
+  if ( !error )
+    result = (FT_Short)((p[0] << 8) | p[1]);
+
+  return error;
+}
+
+FCFT_API( FT_Long )
+fcft_stream_read_long( FT_Stream  stream,
+                       FT_Error  *perror )
+{
+  FT_Byte   temp[4], *p = temp;
+  FT_Long   result = 0;
+  FT_Error  error  = fcft_stream_readp( stream, &p, 4 );
+
+  if ( !error )
+    result = (FT_Long)((FT_Long)(p[0] << 24) |
+                       (FT_Long)(p[1] << 16) |
+                                (p[2] << 8)  |
+                                 p[3]        );
+
+  return error;
+}
+
+
+FCFT_APIDEF( FT_Error )
+fcft_face_goto_table( FT_Face    face,
+                      FT_ULong   the_tag,
+                      FT_Stream  stream )
+{
+  FT_Error  error;
+
+  if ( !FT_IS_SFNT(face) )
+    error = FT_Err_Invalid_Face_Handle;
+  else
+  {
+   /* parse the directory table directly, without using
+    * FreeType's built-in data structures
+    */
+    FT_UInt   count, nn;
+    FT_ULong  offset = 0;
+
+    if ( face->num_faces > 1 )
+    {
+      /* deal with TrueType collections */
+      FT_ULong  offset;
+
+      if ( FCFT_STREAM_SEEK( 12 + face->face_index*4 ) ||
+           FCFT_READ_ULONG(offset)                     )
+        goto Exit;
+    }
+
+    if ( FCFT_STREAM_SEEK( offset+4 ) ||
+         FCFT_READ_USHORT(count)      )
+      goto Exit;
+
+
+    if ( FCFT_STREAM_SEEK( offset+12 ) ||
+         FCFT_FRAME_ENTER( count*16 )  )
+      goto Exit;
+
+    for ( nn = 0; nn < count; nn++ )
+    {
+      FT_ULong  tag      = FCFT_GET_TAG();
+      FT_ULong  checksum = FCFT_GET_ULONG();
+      FT_ULong  start    = FCFT_GET_ULONG();
+      FT_ULong  size     = FCFT_GET_ULONG();
+
+      FT_UNUSED(checksum);
+      FT_UNUSED(size);
+
+      if ( tag == the_tag )
+      {
+        error = fcft_stream_seek( stream, offset+start );
+        goto FoundIt;
+      }
+    }
+    error = FT_Err_Table_Missing;
+
+  FoundIt:
+    FCFT_FRAME_EXIT();
+  }
+
+Exit:
+  return error;
+}
+
+#undef FCFT_QALLOC
diff -uNr fontconfig-2.3.2/src/fcftglue.h fontconfig-2.3.2-new/src/fcftglue.h
--- fontconfig-2.3.2/src/fcftglue.h	1969-12-31 19:00:00.000000000 -0500
+++ fontconfig-2.3.2-new/src/fcftglue.h	2006-08-05 19:47:47.000000000 -0400
@@ -0,0 +1,135 @@
+/* the following contains code used to prevent FontConfig from
+ * abusing FreeType internals. We simply duplicate some of the FreeType
+ * functionality using only publicly defined APIs and structures
+ */
+#ifndef __FONTCONFIG_FTGLUE_H__
+#define __FONTCONFIG_FTGLUE_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+FT_BEGIN_HEADER
+
+
+/* utility macros */
+#define  FCFT_SET_ERR(c)   ( (error = (c)) != 0 )
+
+#ifndef FCFT_API
+#define FCFT_API(x)  extern x
+#endif
+
+#ifndef FCFT_APIDEF
+#define FCFT_APIDEF(x)  x
+#endif
+
+/* stream macros used by the OpenType parser */
+#define  FCFT_STREAM_POS()       fcft_stream_pos( stream )
+#define  FCFT_STREAM_SEEK(pos)   FCFT_SET_ERR( fcft_stream_seek( stream, pos ) )
+#define  FCFT_FRAME_ENTER(size)  FCFT_SET_ERR( fcft_stream_frame_enter( stream, size ) )
+#define  FCFT_FRAME_EXIT()       fcft_stream_frame_exit( stream )
+
+#define  FCFT_GET_BYTE()         fcft_stream_get_byte( stream )
+#define  FCFT_GET_SHORT()        fcft_stream_get_short( stream )
+#define  FCFT_GET_LONG()         fcft_stream_get_long( stream )
+
+#define  FCFT_GET_CHAR()        ((FT_Char)FCFT_GET_BYTE())
+#define  FCFT_GET_USHORT()      ((FT_UShort)FCFT_GET_SHORT())
+#define  FCFT_GET_ULONG()       ((FT_ULong)FCFT_GET_LONG())
+#define  FCFT_GET_TAG()         FCFT_GET_ULONG()
+
+#define  FCFT_READ_(val,type,suffix)   \
+   ( (val) = (type) fcft_stream_read_##suffix (stream, &error), error != 0 )
+
+#define  FCFT_READ_BYTE(val)    FCFT_READ_(val,FT_Byte,byte)
+#define  FCFT_READ_SHORT(val)   FCFT_READ_(val,FT_Short,short)
+#define  FCFT_READ_LONG(val)    FCFT_READ_(val,FT_Long,long)
+
+#define  FCFT_READ_CHAR(val)    FCFT_READ_(val,FT_Char,byte)
+#define  FCFT_READ_USHORT(val)  FCFT_READ_(val,FT_UShort,short)
+#define  FCFT_READ_ULONG(val)   FCFT_READ_(val,FT_ULong,long)
+
+
+FCFT_API( FT_Long )
+fcft_stream_pos( FT_Stream   stream );
+
+FCFT_API( FT_Error )
+fcft_stream_seek( FT_Stream   stream,
+                  FT_Long     pos );
+
+FCFT_API( FT_Error )
+fcft_stream_frame_enter( FT_Stream   stream,
+                         FT_ULong    size );
+
+FCFT_API( void )
+fcft_stream_frame_exit( FT_Stream  stream );
+
+FCFT_API( FT_Byte )
+fcft_stream_get_byte( FT_Stream  stream );
+
+FCFT_API( FT_Short )
+fcft_stream_get_short( FT_Stream  stream );
+
+FCFT_API( FT_Long )
+fcft_stream_get_long( FT_Stream   stream );
+
+FCFT_API( FT_Byte )
+fcft_stream_read_byte( FT_Stream   stream,
+                       FT_Error   *perror );
+
+FCFT_API( FT_Short )
+fcft_stream_read_short( FT_Stream  stream,
+                        FT_Error  *perror );
+
+FCFT_API( FT_Long )
+fcft_stream_read_long( FT_Stream  stream,
+                       FT_Error  *perror );
+
+FCFT_API( FT_Error )
+fcft_face_goto_table( FT_Face    face,
+                      FT_ULong   tag,
+                      FT_Stream  stream );
+
+/* memory macros used by the OpenType parser */
+#define  FCFT_MEM_ALLOC(_ptr,_size)   \
+           ( (_ptr) = fcft_alloc( memory, _size, &error ), error != 0 )
+
+#define  FCFT_MEM_REALLOC(_ptr,_oldsz,_newsz)  \
+           ( (_ptr) = fcft_realloc( memory, (_ptr), (_oldsz), (_newsz), &error ), error != 0 )
+
+#define  FCFT_FREE(_ptr)               \
+  FT_BEGIN_STMNT                       \
+    if ( (_ptr) )                      \
+    {                                  \
+      fcft_free( memory, _ptr );       \
+      _ptr = NULL;                     \
+    }                                  \
+  FT_END_STMNT
+
+#define  FCFT_MEM_ALLOC_ARRAY(_ptr,_count,_type)   \
+           FCFT_MEM_ALLOC(_ptr,(_count)*sizeof(_type))
+
+#define  FCFT_MEM_REALLOC_ARRAY(_ptr,_oldcnt,_newcnt,_type) \
+           FCFT_MEM_REALLOC(_ptr,(_oldcnt)*sizeof(_type),(_newcnt)*sizeof(_type))
+
+
+FCFT_API( FT_Pointer )
+fcft_alloc( FT_Memory  memory,
+            FT_ULong   size,
+            FT_Error  *perror );
+
+FCFT_API( FT_Pointer )
+fcft_realloc( FT_Memory   memory,
+              FT_Pointer  block,
+              FT_ULong    old_size,
+              FT_ULong    new_size,
+              FT_Error   *perror );
+
+FCFT_API( void )
+fcft_free( FT_Memory   memory,
+           FT_Pointer  block );
+
+/* */
+
+FT_END_HEADER
+
+#endif /* __OPENTYPE_FCFT_H__ */
