diff --git a/django/contrib/sites/managers.py b/django/contrib/sites/managers.py
index 3df485a..58896ee 100644
--- a/django/contrib/sites/managers.py
+++ b/django/contrib/sites/managers.py
@@ -1,6 +1,7 @@
 from django.conf import settings
 from django.db import models
 from django.db.models.fields import FieldDoesNotExist
+from django.db.models.sql import constants
 
 class CurrentSiteManager(models.Manager):
     "Use this to limit objects to those associated with the current site."
@@ -8,33 +9,68 @@ class CurrentSiteManager(models.Manager):
         super(CurrentSiteManager, self).__init__()
         self.__field_name = field_name
         self.__is_validated = False
-        
+
     def _validate_field_name(self):
-        field_names = self.model._meta.get_all_field_names()
-        
-        # If a custom name is provided, make sure the field exists on the model
-        if self.__field_name is not None and self.__field_name not in field_names:
-            raise ValueError("%s couldn't find a field named %s in %s." % \
-                (self.__class__.__name__, self.__field_name, self.model._meta.object_name))
-        
-        # Otherwise, see if there is a field called either 'site' or 'sites'
-        else:
-            for potential_name in ['site', 'sites']:
+        """
+        Given the field identifier, goes down the chain to check that each
+        specified field
+
+            a) exists,
+            b) is of type ForeignKey or ManyToManyField
+
+        If no field name is specified when instantiating
+        CurrentSiteManager, it tries to find either 'site' or 'sites'
+        as the site link.
+        """
+        if self.__field_name is None:
+            # Guess at field name
+            field_names = self.model._meta.get_all_field_names()
+            for potential_name in ('site', 'sites'):
                 if potential_name in field_names:
                     self.__field_name = potential_name
-                    self.__is_validated = True
                     break
-        
-        # Now do a type check on the field (FK or M2M only)
+            else:
+                raise ValueError(
+                    "%s couldn't find a field named either "
+                    "'site' or 'sites' in %s." %
+                    (self.__class__.__name__, self.model._meta.object_name))
+
+        fieldname_chain = self.__field_name.split(constants.LOOKUP_SEP)
+        model = self.model
+
+        for field_name in fieldname_chain:
+            # Throws an exception if anything goes bad
+            self._validate_single_field_name(model, field_name)
+            model = self._get_related_model(model, field_name)
+
+        # If we get this far without an exception, everything is good
+        self.__is_validated = True
+
+    def _validate_single_field_name(self, model, field_name):
+        """
+        Checks if the given field name can be used to make a link between a
+        model and a site with the CurrentSiteManager class
+        """
         try:
-            field = self.model._meta.get_field(self.__field_name)
-            if not isinstance(field, (models.ForeignKey, models.ManyToManyField)):
-                raise TypeError("%s must be a ForeignKey or ManyToManyField." %self.__field_name)
+            field = model._meta.get_field(field_name)
+            if not isinstance(field, (models.ForeignKey,
+                                      models.ManyToManyField)):
+                raise TypeError(
+                    "Field %s of model %s must be a ForeignKey "
+                    "or ManyToManyField." %
+                    (field_name, model._meta.object_name))
         except FieldDoesNotExist:
-            raise ValueError("%s couldn't find a field named %s in %s." % \
-                    (self.__class__.__name__, self.__field_name, self.model._meta.object_name))
-        self.__is_validated = True
-    
+            raise ValueError(
+                "%s couldn't find a field named %s in %s." %
+                (self.__class__.__name__, field_name, model._meta.object_name))
+
+    def _get_related_model(self, model, fieldname):
+        """
+        Given a model and the name of a ForeignKey or ManyToManyField field
+        name as a string, returns the associated model.
+        """
+        return model._meta.get_field_by_name(fieldname)[0].rel.to
+
     def get_query_set(self):
         if not self.__is_validated:
             self._validate_field_name()
diff --git a/docs/ref/contrib/sites.txt b/docs/ref/contrib/sites.txt
index 8fc434b..7cf5106 100644
--- a/docs/ref/contrib/sites.txt
+++ b/docs/ref/contrib/sites.txt
@@ -174,7 +174,7 @@ fallback for cases where it is not installed.
 .. function:: get_current_site(request)
 
     Checks if contrib.sites is installed and returns either the current
-    :class:`~django.contrib.sites.models.Site` object or a 
+    :class:`~django.contrib.sites.models.Site` object or a
     :class:`~django.contrib.sites.models.RequestSite` object based on
     the request.
 
@@ -349,6 +349,33 @@ demonstrates this::
 If you attempt to use :class:`~django.contrib.sites.managers.CurrentSiteManager`
 and pass a field name that doesn't exist, Django will raise a ``ValueError``.
 
+Spanning relationships
+----------------------
+
+.. versionchanged:: 1.5
+
+:class:`~django.contrib.sites.managers.CurrentSiteManager` can span
+multiple models by using the same syntax as queries, as per the
+:ref:`models and database queries documentation
+<lookups-that-span-relationships>`. For example, using the ``Photo``
+model defined above::
+
+    from django.db import models
+    from django.contrib.sites.managers import CurrentSiteManager
+
+    class PhotoLocation(models.Model):
+        name = models.CharField(max_length=100)
+        photo = models.ForeignKey(Photo)
+        objects = models.Manager()
+        on_site = CurrentSiteManager('photo__publish_on')
+
+``PhotoLocation.on_site.all()`` will return all ``PhotoLocation`` objects
+in the database associated with ``Photo`` objects which themselves are
+associated with the current site.
+
+Keeping default manager
+-----------------------
+
 Finally, note that you'll probably want to keep a normal
 (non-site-specific) ``Manager`` on your model, even if you use
 :class:`~django.contrib.sites.managers.CurrentSiteManager`. As
@@ -437,7 +464,7 @@ fallback when the database-backed sites framework is not available.
 
         Sets the ``name`` and ``domain`` attributes to the value of
         :meth:`~django.http.HttpRequest.get_host`.
-        
+
 
 A :class:`~django.contrib.sites.models.RequestSite` object has a similar
 interface to a normal :class:`~django.contrib.sites.models.Site` object, except
diff --git a/tests/regressiontests/sites_framework/models.py b/tests/regressiontests/sites_framework/models.py
index 9ecc3e6..90d26f1 100644
--- a/tests/regressiontests/sites_framework/models.py
+++ b/tests/regressiontests/sites_framework/models.py
@@ -34,3 +34,10 @@ class InvalidArticle(AbstractArticle):
 
 class ConfusedArticle(AbstractArticle):
     site = models.IntegerField()
+
+class ArticleComment(models.Model):
+    parent_article = models.ForeignKey(ExclusiveArticle)
+    text = models.CharField(max_length=50)
+
+    objects = models.Manager()
+    on_site = CurrentSiteManager("parent_article__site")
diff --git a/tests/regressiontests/sites_framework/tests.py b/tests/regressiontests/sites_framework/tests.py
index 8e664fd..73a07d0 100644
--- a/tests/regressiontests/sites_framework/tests.py
+++ b/tests/regressiontests/sites_framework/tests.py
@@ -5,7 +5,7 @@ from django.contrib.sites.models import Site
 from django.test import TestCase
 
 from .models import (SyndicatedArticle, ExclusiveArticle, CustomArticle,
-    InvalidArticle, ConfusedArticle)
+    InvalidArticle, ConfusedArticle, ArticleComment)
 
 
 class SitesFrameworkTestCase(TestCase):
@@ -36,3 +36,20 @@ class SitesFrameworkTestCase(TestCase):
     def test_invalid_field_type(self):
         article = ConfusedArticle.objects.create(title="More Bad News!", site=settings.SITE_ID)
         self.assertRaises(TypeError, ConfusedArticle.on_site.all)
+
+    def test_indirect_link(self):
+        article_inside = ExclusiveArticle.objects.create(
+            title="Article in current site",
+            site_id=settings.SITE_ID)
+        article_outside = ExclusiveArticle.objects.create(
+            title="Article in another site",
+            site_id=settings.SITE_ID + 1)
+
+        comment_inside = ArticleComment.objects.create(
+            parent_article=article_inside,
+            text="Post to article in current side.")
+        comment_outside = ArticleComment.objects.create(
+            parent_article=article_outside,
+            text="Post to article in another site.")
+
+        self.assertEqual(ArticleComment.on_site.all().get(), comment_inside)
