diff --git a/context.go b/context.go
index a946468..86f4ef5 100644
--- a/context.go
+++ b/context.go
@@ -12,6 +12,10 @@
 	AuthEndpoint string
 }
 
+// ReauthHandlerFunc functions are responsible for somehow performing the task of
+// reauthentication.
+type ReauthHandlerFunc func() error
+
 // Context structures encapsulate Gophercloud-global state in a manner which
 // facilitates easier unit testing.  As a user of this SDK, you'll never
 // have to use this structure, except when contributing new code to the SDK.
@@ -21,6 +25,17 @@
 
 	// httpClient refers to the current HTTP client interface to use.
 	httpClient *http.Client
+
+	// reauthHandler provides the functionality needed to re-authenticate
+	// if that feature is enabled.  Note: in order to allow for automatic
+	// re-authentication, the Context object will need to remember your
+	// username, password, and tenant ID as provided in the initial call
+	// to Authenticate().  If you do not desire this, you'll need to handle
+	// reauthentication yourself through other means.  Two methods exist:
+	// the first approach is to just handle errors yourself at the application
+	// layer, and the other is through a custom reauthentication handler
+	// set through the WithReauthHandler() method.
+	reauthHandler ReauthHandlerFunc
 }
 
 // TestContext yields a new Context instance, pre-initialized with a barren
@@ -92,3 +107,15 @@
 
 	return gcp, nil
 }
+
+// WithReauthHandler configures the context to handle reauthentication attempts using the supplied
+// funtion.  By default, reauthentication happens by invoking Authenticate(), which is unlikely to be
+// useful in a unit test.
+//
+// Do not confuse this function with WithReauth()!  Although they work together to support reauthentication,
+// WithReauth() actually contains the decision-making logic to determine when to perform a reauth,
+// while WithReauthHandler() is used to configure what a reauth actually entails.
+func (c *Context) WithReauthHandler(f ReauthHandlerFunc) *Context {
+	c.reauthHandler = f
+	return c
+}
diff --git a/reauth.go b/reauth.go
new file mode 100644
index 0000000..98fba55
--- /dev/null
+++ b/reauth.go
@@ -0,0 +1,23 @@
+package gophercloud
+
+import (
+	"github.com/racker/perigee"
+)
+
+// WithReauth wraps a Perigee request fragment with logic to perform re-authentication
+// if it's deemed necessary.
+//
+// Do not confuse this function with WithReauth()!  Although they work together to support reauthentication,
+// WithReauth() actually contains the decision-making logic to determine when to perform a reauth,
+// while WithReauthHandler() is used to configure what a reauth actually entails.
+func (c *Context) WithReauth(f func() (interface{}, error)) (interface{}, error) {
+	result, err := f()
+	cause, ok := err.(*perigee.UnexpectedResponseCodeError)
+	if ok && cause.Actual == 401 {
+		err = c.reauthHandler()
+		if err == nil {
+			result, err = f()
+		}
+	}
+	return result, err
+}
\ No newline at end of file
diff --git a/reauth_test.go b/reauth_test.go
new file mode 100644
index 0000000..e04968a
--- /dev/null
+++ b/reauth_test.go
@@ -0,0 +1,109 @@
+package gophercloud
+
+import (
+	"testing"
+	"github.com/racker/perigee"
+)
+
+// This reauth-handler does nothing, and returns no error.
+func doNothing() error {
+	return nil
+}
+
+func TestOtherErrorsPropegate(t *testing.T) {
+	calls := 0
+	c := TestContext().WithReauthHandler(doNothing)
+
+	myObj, err := c.WithReauth(func() (interface{}, error) {
+		calls++
+		return nil, &perigee.UnexpectedResponseCodeError{
+			Expected: []int{204},
+			Actual: 404,
+		}
+	})
+
+	if myObj != nil {
+		t.Errorf("Returned nil myObj; got %#v", myObj)
+		return
+	}
+	if err == nil {
+		t.Error("Expected MyError to be returned; got nil instead.")
+		return
+	}
+	if _, ok := err.(*perigee.UnexpectedResponseCodeError); !ok {
+		t.Error("Expected UnexpectedResponseCodeError; got %#v", err)
+		return
+	}
+	if calls != 1 {
+		t.Errorf("Expected the body to be invoked once; found %d calls instead", calls)
+		return
+	}
+}
+
+func Test401ErrorCausesBodyInvokation2ndTime(t *testing.T) {
+	calls := 0
+	c := TestContext().WithReauthHandler(doNothing)
+
+	myObj, err := c.WithReauth(func() (interface{}, error) {
+		calls++
+		return nil, &perigee.UnexpectedResponseCodeError{
+			Expected: []int{204},
+			Actual: 401,
+		}
+	})
+
+	if myObj != nil {
+		t.Errorf("Returned nil myObj; got %#v", myObj)
+		return
+	}
+	if err == nil {
+		t.Error("Expected MyError to be returned; got nil instead.")
+		return
+	}
+	if calls != 2 {
+		t.Errorf("Expected the body to be invoked once; found %d calls instead", calls)
+		return
+	}
+}
+
+func TestReauthAttemptShouldHappen(t *testing.T) {
+	calls := 0
+	c := TestContext().WithReauthHandler(func() error {
+		calls++
+		return nil
+	})
+	c.WithReauth(func() (interface{}, error) {
+		return nil, &perigee.UnexpectedResponseCodeError{
+			Expected: []int{204},
+			Actual: 401,
+		}
+	})
+
+	if calls != 1 {
+		t.Errorf("Expected Reauthenticator to be called once; found %d instead", calls)
+		return
+	}
+}
+
+type MyError struct {}
+func (*MyError) Error() string {
+	return "MyError instance"
+}
+
+func TestReauthErrorShouldPropegate(t *testing.T) {
+	c := TestContext().WithReauthHandler(func() error {
+		return &MyError{}
+	})
+
+	_, err := c.WithReauth(func() (interface{}, error) {
+		return nil, &perigee.UnexpectedResponseCodeError{
+			Expected: []int{204},
+			Actual: 401,
+		}
+	})
+
+	if _, ok := err.(*MyError); !ok {
+		t.Errorf("Expected a MyError; got %#v", err)
+		return
+	}
+}