diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,44 @@
+# 0.4.2.1 - November 18th, 2026
+
+No API changes from 0.4.2.0.
+
+- `set`, `add`, `replace`, `cas`, `append` and `prepend` reject a value
+  larger than 1GiB, memcached's largest possible item size, with
+  `OpError ErrValueTooLarge` before sending anything. A value of about 2GiB
+  or more (longer than 2147483645 bytes) previously made memcached run the
+  value's bytes as commands, so storing untrusted data could run commands on
+  the server, and a value over 1GiB could time out, be sent again and mark
+  the server dead. Such a value no longer reaches the server, so it no
+  longer makes memcached delete the key's existing value, as memcached does
+  whenever it rejects a store as too large; a value within 1GiB but over the
+  server's own limit (`-I`, 1MiB by default) still does. Every operation
+  that sends a value now evaluates it first, before its timeout starts: an
+  exception it throws is no longer retried and no longer marks the server
+  dead, and time spent computing it no longer counts towards
+  `optsServerTimeout`. The request encoders in `Database.Memcache.Socket`
+  still encode a value of any length; don't send one longer than 1GiB.
+- memcached 1.6.10 or later is now required (previously documented as
+  1.6.0). memcached before 1.6.10 rejects the meta set command this library
+  stores values with, without reading the value that follows it, and then
+  runs the value's bytes as commands, so storing untrusted data could run
+  commands on the server. Each new connection now asks the server for its
+  version before it is used: until that check passes, the only requests sent
+  are the authentication exchange, when credentials are set, and `version`.
+  A server older than 1.6.10, or any other reply that is neither an error
+  nor a readable version, is refused with `ProtocolError (UnknownOp ...)`,
+  whose message quotes the reply; the connection is closed, and the refusal
+  is not retried and doesn't mark the server dead. An error reply, such as
+  `CLIENT_ERROR unauthenticated`, throws what it throws for any request, and
+  so does a reply that can't be parsed, such as an empty line or an overlong
+  one, which counts against the server. This covers ElastiCache discovery,
+  which now fails for a cluster running a memcached older than 1.6.10.
+  Through a proxy, the check sees only the proxy's version, so every
+  memcached behind it must be 1.6.10 or later too. Each new connection that
+  an operation opens takes one more round trip, which counts towards
+  `optsServerTimeout`. Connections made directly with
+  `Database.Memcache.Socket.newConnection` are not checked; send
+  `storeRequest` and `modifyRequest` only to 1.6.10 or later.
+
 # 0.4.2.0 - October 20th, 2026
 
 No API changes from 0.4.0.0. This is the first Hackage release since 0.4.0.0,
diff --git a/Database/Memcache/Client.hs b/Database/Memcache/Client.hs
--- a/Database/Memcache/Client.hs
+++ b/Database/Memcache/Client.hs
@@ -14,8 +14,17 @@
 connect to a single Memcached server or a cluster of servers; clusters use
 consistent hashing to route requests to the appropriate server.
 
-This requires memcached 1.6.0 or newer, the first release with the meta
-commands; older servers reject every operation with @ERROR@.
+This requires memcached 1.6.10 or newer. Older servers reject the meta set
+command this client stores values with, without reading the value that
+follows it, and then run the value's bytes as commands. So each new connection
+asks the server for its version before it is used: until that check passes,
+the only requests sent are the authentication exchange, when credentials are
+set, and @version@. Unless the server reports 1.6.10 or later, the connection
+is closed and v'ProtocolError' 'UnknownOp' is thrown, quoting the server's
+reply; an error reply, such as @CLIENT_ERROR unauthenticated@, throws what it
+throws for any request. A refused version isn't retried, and doesn't mark the
+server as failed. Through a proxy, the check sees only the proxy's version, so
+every memcached behind it must be 1.6.10 or later too.
 
 Authentication uses Memcached's experimental text-protocol auth-file mechanism
 (@-Y authfile@), introduced in memcached 1.5.15. Enabling @-Y@ also disables
@@ -136,6 +145,11 @@
 
 -- | Create a client for the supplied servers. An empty list uses the default
 -- local server specification.
+--
+-- Nothing is sent until an operation needs a connection to a server. Each new
+-- connection then checks the server's version, and refuses a server older than
+-- memcached 1.6.10: until the check passes, the only requests sent are the
+-- authentication exchange, when credentials are set, and @version@.
 newClient :: [ServerSpec] -> Options -> IO Client
 newClient scs = newCluster $ if null scs then [def] else scs
 
@@ -198,6 +212,11 @@
 
 -- | Store a new (or overwrite existing) key-value pair, returning its @Version@
 -- identifier. Use an expiration value of @0@ to store forever.
+--
+-- A value larger than 1 GiB, the largest item memcached can store, is
+-- rejected with 'OpError' 'ErrValueTooLarge' before anything is sent, as it
+-- is by every operation that sends a value. memcached itself rejects a value
+-- too large for its item size limit (its @-I@ option) with the same status.
 set :: Cluster -> Key -> Value -> Flags -> Expiration -> IO Version
 set c k v f e = store c k v f e 0 Set "SET"
 
@@ -211,6 +230,7 @@
 -- with 'set'.
 cas :: Cluster -> Key -> Value -> Flags -> Expiration -> Version -> IO (Maybe Version)
 cas c k v f e ver = do
+  checkValue v
   response <- keyedOp c k (\wire -> storeRequest Set wire v f e ver)
   status <- responseStatus response
   case status of
@@ -224,6 +244,7 @@
 -- expiration value of @0@ to store forever.
 add :: Cluster -> Key -> Value -> Flags -> Expiration -> IO (Maybe Version)
 add c k v f e = do
+  checkValue v
   response <- keyedOp c k (\wire -> storeRequest Add wire v f e 0)
   status <- responseStatus response
   case status of
@@ -239,6 +260,7 @@
 -- server, otherwise 'Nothing' is returned. A version of @0@ skips the check.
 replace :: Cluster -> Key -> Value -> Flags -> Expiration -> Version -> IO (Maybe Version)
 replace c k v f e ver = do
+  checkValue v
   response <- keyedOp c k (\wire -> storeRequest Replace wire v f e ver)
   status <- responseStatus response
   case status of
@@ -250,12 +272,27 @@
 
 store :: Cluster -> Key -> Value -> Flags -> Expiration -> Version -> StoreMode -> String -> IO Version
 store c k v f e ver mode operation = do
+  checkValue v
   response <- keyedOp c k (\wire -> storeRequest mode wire v f e ver)
   status <- responseStatus response
   case status of
     NoError -> return $ responseCas response
     _ -> failResponse response operation
 
+-- | The largest value memcached can store: 1 GiB, its
+-- @ITEM_SIZE_MAX_UPPER_LIMIT@, which caps its @-I@ item size option.
+maxValueLength :: Int
+maxValueLength = 1073741824
+
+-- | Throw 'OpError' 'ErrValueTooLarge', the status memcached returns for a
+-- value too large to store, if the value is longer than @maxValueLength@.
+-- Every operation that sends a value calls this first, so that nothing is
+-- sent: memcached mishandles a data length over 2147483645 bytes and then
+-- runs the rest of the value's bytes as commands. This evaluates the value
+-- before a connection is taken.
+checkValue :: Value -> IO ()
+checkValue v = when (B.length v > maxValueLength) $ throwStatus ErrValueTooLarge
+
 -- | Increment a numeric value stored against a key, returning the incremented
 -- value and the @Version@ identifier of the key-value pair. Throws
 -- 'OpError' 'ErrValueNonNumeric' if the stored value isn't a number.
@@ -315,6 +352,7 @@
 
 modify :: Cluster -> Key -> Value -> Version -> StoreMode -> String -> IO (Maybe Version)
 modify c k v ver mode operation = do
+  checkValue v
   response <- keyedOp c k (\wire -> modifyRequest mode wire v ver)
   status <- responseStatus response
   case status of
diff --git a/Database/Memcache/Cluster.hs b/Database/Memcache/Cluster.hs
--- a/Database/Memcache/Cluster.hs
+++ b/Database/Memcache/Cluster.hs
@@ -71,6 +71,10 @@
         -- | How long to wait for an operation to complete before considering
         -- it failed.
         --
+        -- When an attempt at an operation has to open a new connection, this
+        -- also covers opening it: connecting, authenticating when there are
+        -- credentials, and asking the server for its version.
+        --
         -- Default is 750ms.
         optsServerTimeout        :: Milli,
         -- | Figure out which server to talk to for a given key.
@@ -310,7 +314,9 @@
 
 -- | A rejected command or a reported operation status is an answer, not a
 -- server failure: retrying it will fail identically and must not count towards
--- marking the server dead.
+-- marking the server dead. That includes the 'UnknownOp' a new connection
+-- throws when it refuses the server's version: a retry would find the same
+-- version.
 clientFault :: SomeException -> Bool
 clientFault err = case fromException err of
     Just (ProtocolError BadCommand{}) -> True
diff --git a/Database/Memcache/ElastiCacheClient.hs b/Database/Memcache/ElastiCacheClient.hs
--- a/Database/Memcache/ElastiCacheClient.hs
+++ b/Database/Memcache/ElastiCacheClient.hs
@@ -79,6 +79,11 @@
 --
 -- This function discovers all the nodes in a cluster and sets up a new thread to run autodiscovery on an interval.
 --
+-- Discovery connects to the configuration endpoint like any other server, so
+-- it fails for a cluster running a memcached older than 1.6.10, having sent
+-- only the authentication exchange, when the endpoint has credentials, and
+-- @version@ (see "Database.Memcache.Client").
+--
 -- N.B. The interval is in the same units as 'threadDelay'.
 newClient :: Options -> Int -> ConfigurationEndpoint -> IO Client
 newClient options interval cfgEndpoint = bracket acquireCfgClient releaseCfgClient resolveCluster'
diff --git a/Database/Memcache/Errors.hs b/Database/Memcache/Errors.hs
--- a/Database/Memcache/Errors.hs
+++ b/Database/Memcache/Errors.hs
@@ -54,7 +54,12 @@
 data ProtocolError
     -- | Received an unknown response line.
     = UnknownPkt    { protocolError :: String }
-    -- | Unknown Memcached operation.
+    -- | Unknown Memcached operation. Also thrown when a new connection asks
+    -- the server for its version and the reply is a version below 1.6.10, or
+    -- any other reply that is neither an error nor a readable version; the
+    -- message quotes the reply. The connection is then closed, having sent
+    -- only the authentication exchange, when credentials are set, and
+    -- @version@.
     | UnknownOp     { protocolError :: String }
     -- | Unknown Memcached status field value.
     | UnknownStatus { protocolError :: String }
diff --git a/Database/Memcache/Server.hs b/Database/Memcache/Server.hs
--- a/Database/Memcache/Server.hs
+++ b/Database/Memcache/Server.hs
@@ -1,5 +1,6 @@
-{-# LANGUAGE RecordWildCards #-}
-{-# LANGUAGE CPP             #-}
+{-# LANGUAGE RecordWildCards   #-}
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE OverloadedStrings #-}
 
 {-|
 Module      : Database.Memcache.Server
@@ -12,6 +13,13 @@
 
 Handles the connections between a Memcached client and a single server.
 
+Each new connection is authenticated, when its 'ServerSpec' has credentials,
+and then asks the server for its version before it is used. Unless the server
+reports memcached 1.6.10 or later, the connection is closed, having sent
+nothing but the authentication exchange, when there are credentials, and
+@version@, and v'ProtocolError' 'UnknownOp' is thrown (or, for an error reply,
+what that reply throws for any request).
+
 Memcached expected errors (part of the protocol) are returned in the Response;
 unexpected errors, such as network failures, are thrown as exceptions. The
 server's 'failed' timestamp is used by cluster retry handling.
@@ -25,8 +33,12 @@
     ) where
 
 import           Database.Memcache.Auth
+import           Database.Memcache.Errors
 import           Database.Memcache.Socket
 
+import           Control.Monad            (void, when)
+import qualified Data.ByteString.Char8    as C
+import           Data.Char                (isDigit)
 import           Data.Default
 import           Data.Hashable
 import           Data.IORef
@@ -149,8 +161,60 @@
             S.setSocketOption s S.NoDelay 1
             buffered <- newConnection s
             authenticate buffered ssAuth
+            checkVersion buffered
             return buffered
         )
+
+-- | The oldest memcached this client works with. From 1.6.10, the meta set
+-- command that every store sends takes the data length as the token after
+-- the key. Older servers reject the command without reading the data that
+-- follows it, and then run the stored value's bytes as commands.
+minimumVersion :: (Integer, Integer, Integer)
+minimumVersion = (1, 6, 10)
+
+-- | Ask the server for its version, and throw unless it is at least
+-- @minimumVersion@. Every new connection does this, after authenticating when
+-- there are credentials, before it is used for anything else; @connectSocket@
+-- closes the connection when this throws.
+--
+-- An error reply, such as @CLIENT_ERROR unauthenticated@ from a server in
+-- auth-file mode when no credentials are set, throws what it throws as the
+-- reply to any request. Any other reply that isn't @VERSION@ and a version of
+-- at least @minimumVersion@ throws v'ProtocolError' 'UnknownOp', quoting the
+-- reply and naming the minimum. Retries treat that as a client fault, like a
+-- rejected command: the server's version won't change on a retry, so the
+-- operation fails at once and the server isn't marked as failed.
+checkVersion :: Connection -> IO ()
+checkVersion connection = do
+    sendRaw connection versionRequest
+    response <- recvResponse connection
+    when (responseCode response `elem` ["ERROR", "CLIENT_ERROR", "SERVER_ERROR"]) $
+        void (responseStatus response)
+    case responseVersion response of
+        Just v | v >= minimumVersion -> return ()
+        _ -> throwIO $ ProtocolError UnknownOp
+            { protocolError = "memcached " <> showVersion minimumVersion
+                <> " or later is required, but the server answered version with "
+                <> show (C.unwords (responseCode response : responseTokens response))
+            }
+  where
+    showVersion (major, minor, patch) =
+        show major <> "." <> show minor <> "." <> show patch
+
+-- | The version in a @VERSION@ reply, as its first three numbers: major,
+-- minor and patch, separated by dots. Anything after the third number, such
+-- as a @-rc1@ suffix or a word after the version, is ignored.
+responseVersion :: Response -> Maybe (Integer, Integer, Integer)
+responseVersion (Response "VERSION" (token:_) _) = do
+    (major, afterMajor) <- number token
+    (minor, afterMinor) <- number =<< C.stripPrefix "." afterMajor
+    (patch, _)          <- number =<< C.stripPrefix "." afterMinor
+    return (major, minor, patch)
+  where
+    number bytes = case C.span isDigit bytes of
+        (digits, remainder) | not (C.null digits) -> Just (read (C.unpack digits), remainder)
+        _ -> Nothing
+responseVersion _ = Nothing
 
 releaseSocket :: Connection -> IO ()
 releaseSocket = closeConnection
diff --git a/Database/Memcache/Socket.hs b/Database/Memcache/Socket.hs
--- a/Database/Memcache/Socket.hs
+++ b/Database/Memcache/Socket.hs
@@ -67,6 +67,11 @@
   } deriving (Eq, Show)
 
 -- | Create a connection wrapper around a socket.
+--
+-- This doesn't check the server's version. Connections that
+-- "Database.Memcache.Server" makes are checked, and refuse a server older than
+-- memcached 1.6.10; a connection made here directly is not, so check the
+-- server's version before sending it 'storeRequest' or 'modifyRequest'.
 newConnection :: N.Socket -> IO Connection
 newConnection s = Connection s <$> newIORef B.empty
 
@@ -341,6 +346,16 @@
   <> bytes " c" <> bytes crlf
 
 -- | Encode a storage request.
+--
+-- Send this only to memcached 1.6.10 or later. Older servers reject it without
+-- reading the value, and then run the value's bytes as commands. Connections
+-- that "Database.Memcache.Server" makes check the server's version, but a
+-- connection made with 'newConnection' directly does not.
+--
+-- Nor send a value longer than 1 GiB, the largest item memcached can store:
+-- memcached mishandles a data length over 2147483645 bytes, and then runs the
+-- rest of the value's bytes as commands. The operations in
+-- "Database.Memcache.Client" refuse such a value; this encoder doesn't.
 storeRequest :: StoreMode -> WireKey -> Value -> Flags -> Expiration -> Version -> ByteString
 storeRequest mode key value flags expiry version = render (B.length (wireKey key) + B.length value) $
   bytes cmdMetaSet <> bytes " " <> bytes (wireKey key) <> bytes " " <> intDec (B.length value)
@@ -361,6 +376,16 @@
   <> bytes crlf
 
 -- | Encode an append or prepend request.
+--
+-- Send this only to memcached 1.6.10 or later. Older servers reject it without
+-- reading the value, and then run the value's bytes as commands. Connections
+-- that "Database.Memcache.Server" makes check the server's version, but a
+-- connection made with 'newConnection' directly does not.
+--
+-- Nor send a value longer than 1 GiB, the largest item memcached can store:
+-- memcached mishandles a data length over 2147483645 bytes, and then runs the
+-- rest of the value's bytes as commands. The operations in
+-- "Database.Memcache.Client" refuse such a value; this encoder doesn't.
 modifyRequest :: StoreMode -> WireKey -> Value -> Version -> ByteString
 modifyRequest mode key value version = render (B.length (wireKey key) + B.length value) $
   bytes cmdMetaSet <> bytes " " <> bytes (wireKey key) <> bytes " " <> intDec (B.length value)
diff --git a/Database/Memcache/Types.hs b/Database/Memcache/Types.hs
--- a/Database/Memcache/Types.hs
+++ b/Database/Memcache/Types.hs
@@ -49,7 +49,9 @@
     | ErrKeyNotFound
     -- | The key already exists.
     | ErrKeyExists
-    -- | The value exceeds the server limit.
+    -- | The value exceeds the server limit. The client also throws this,
+    -- without sending anything, for a value larger than 1 GiB, the largest
+    -- item memcached can store.
     | ErrValueTooLarge
     -- | The item was not stored.
     | ErrItemNotStored
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -15,8 +15,20 @@
 connecting to a cluster, consistent hashing is used for routing requests to
 the appropriate server.
 
-**This library requires memcached 1.6.0 or newer**, the first release with the
-meta commands. Against older servers every operation is rejected with `ERROR`.
+**This library requires memcached 1.6.10 or newer.** Older servers reject the
+meta set command this library stores values with, without reading the value
+that follows it, and then run the value's bytes as commands. So each new
+connection asks the server for its version before it is used: until that check
+passes, the only requests sent are the authentication exchange, when
+credentials are set, and `version`. Unless the server reports 1.6.10 or later,
+the connection is closed and the operation fails with
+`ProtocolError (UnknownOp message)`, where the message quotes the server's
+reply, or, if the server answered with an error such as
+`CLIENT_ERROR unauthenticated`, with the error that reply gives any request. A
+refused version isn't retried, and doesn't mark the server as failed. The
+check sees only the server the client connects to: through a proxy, such as
+memcached's own `-o proxy_config` mode, it sees the proxy's version, so every
+memcached behind a proxy must be 1.6.10 or newer too.
 
 Authentication uses a memcached auth file with `-Y authfile`, an experimental
 ASCII-protocol auth mode added in memcached 1.5.15; the old binary protocol
@@ -117,6 +129,9 @@
   mc <- EC.newClient M.def (60 * 1000000) endpoint
 ```
 
+Discovery connects to the configuration endpoint like any other server, so it
+fails for a cluster running a memcached older than 1.6.10.
+
 ## Licensing
 
 This library is BSD-licensed.
@@ -188,7 +203,7 @@
 - `spec` holds the unit and property tests, which run against an in-process
   mock server and need nothing installed.
 - `integration` starts its own `memcached` servers on free local ports and
-  tests against them, so it needs memcached 1.6 or newer on your `PATH`.
+  tests against them, so it needs memcached 1.6.10 or newer on your `PATH`.
   Without it, the suite reports a single pending test instead of failing.
   memcached refuses to run as root without `-u`, so run the suite as an
   ordinary user.
diff --git a/memcache.cabal b/memcache.cabal
--- a/memcache.cabal
+++ b/memcache.cabal
@@ -1,6 +1,6 @@
 cabal-version: 3.0
 name:          memcache
-version:       0.4.2.0
+version:       0.4.2.1
 synopsis:      A memcached client library.
 description:
   A client library for a Memcached cluster. Memcached is an in-memory key-value
@@ -8,8 +8,11 @@
   group of Memcached servers and perform out-of-band caching for things like
   SQL results, rendered pages, or third-party APIs.
 
-  It uses the Memcached Meta Text protocol and requires memcached 1.6.0 or
-  newer. Username/password authentication is supported through memcached's
+  It uses the Memcached Meta Text protocol and requires memcached 1.6.10 or
+  newer: each new connection checks the server's version, and refuses an
+  older server. Until the check passes, the only requests sent are the
+  authentication exchange, when credentials are set, and @version@.
+  Username/password authentication is supported through memcached's
   @-Y authfile@ mode; the binary protocol and SASL authentication are no longer
   supported. It supports connecting to a single, or a cluster of Memcached
   servers. When connecting to a cluster, consistent hashing is used for routing
diff --git a/test/MockServer.hs b/test/MockServer.hs
--- a/test/MockServer.hs
+++ b/test/MockServer.hs
@@ -5,7 +5,8 @@
 -- Each mock listens on its own ephemeral port on 127.0.0.1, so tests can run
 -- several at once and never clash with a real memcached on the default port.
 module MockServer (
-        MockResponse(..), MockServer(..), withMockServer, mockServerSpec
+        MockResponse(..), MockServer(..), withMockServer, withMockMemcached,
+        mockServerSpec
     ) where
 
 import           Control.Concurrent
@@ -49,7 +50,18 @@
 -- in order, one per request, across however many connections the client
 -- makes; once they run out it closes the connection and stops listening.
 withMockServer :: [MockResponse] -> (MockServer -> IO a) -> IO a
-withMockServer responses action = do
+withMockServer = runMockServer Nothing
+
+-- | Like 'withMockServer', but the mock reports itself as memcached of the
+-- given version, such as @"1.6.24"@. The client asks for the server's version
+-- on every new connection before sending anything else, so the mock answers
+-- the first request on each connection with @VERSION@ and that version,
+-- without using up a response. That request is still recorded.
+withMockMemcached :: B.ByteString -> [MockResponse] -> (MockServer -> IO a) -> IO a
+withMockMemcached version = runMockServer (Just ("VERSION " <> version <> "\r\n"))
+
+runMockServer :: Maybe B.ByteString -> [MockResponse] -> (MockServer -> IO a) -> IO a
+runMockServer greeting responses action = do
   ready <- newEmptyMVar
   received <- newIORef []
   bracket
@@ -79,9 +91,16 @@
       pending <- readIORef remaining
       unless (null pending) $ do
         (client, _) <- N.accept sock
-        handle ignore (clientHandler client remaining received)
+        handle ignore (greet client received >> clientHandler client remaining received)
           `finally` N.close client
         acceptLoop sock remaining received
+
+    -- Answer the version check that starts each connection, if the mock
+    -- reports a version.
+    greet client received = forM_ greeting $ \reply -> do
+      request <- recvReq client
+      modifyIORef' received (request :)
+      N.sendAll client reply
 
     ignore :: SomeException -> IO ()
     ignore = const (return ())
diff --git a/test/Spec.hs b/test/Spec.hs
--- a/test/Spec.hs
+++ b/test/Spec.hs
@@ -16,11 +16,15 @@
 import qualified Data.ByteString           as B
 import qualified Data.ByteString.Base64    as Base64
 import qualified Data.ByteString.Char8     as C
+import           Data.ByteString.Unsafe    (unsafePackMallocCStringLen)
 import qualified Network.Socket            as N
 import qualified Network.Socket.ByteString as N
 import           Control.Concurrent        (forkIO, threadDelay)
 import           Control.Exception         (bracket)
+import           Control.Monad             (forM_, void)
 import           Data.Either               (isLeft)
+import           Data.List                 (isInfixOf)
+import           Foreign.Marshal.Alloc     (mallocBytes)
 import           System.Timeout            (timeout)
 
 main :: IO ()
@@ -278,7 +282,7 @@
       withServerAndClient [MR "VA 5 f1 c11 kone\r\nfirst\r\n", Noop, MR "MN\r\n"] $ \server client -> do
         Client.getMany client ["one", "two"] `shouldReturn` [("one", ("first", 1, 11))]
         mockRequests server `shouldReturn`
-          ["mg one v f c k q\r\n", "mg two v f c k q\r\n", "mn\r\n"]
+          ["version\r\n", "mg one v f c k q\r\n", "mg two v f c k q\r\n", "mn\r\n"]
 
     it "maps encoded keys back to the caller's key" $ do
       let encoded = Base64.encode "a b"
@@ -294,7 +298,7 @@
     it "gets a hit" $
       withServerAndClient [MR "VA 3 f2 c7\r\nfoo\r\n"] $ \server client -> do
         Client.get client "key" `shouldReturn` Just ("foo", 2, 7)
-        mockRequests server `shouldReturn` ["mg key v f c\r\n"]
+        mockRequests server `shouldReturn` ["version\r\n", "mg key v f c\r\n"]
 
     it "returns Nothing for a miss" $
       withClient [MR "EN\r\n"] $ \client ->
@@ -312,7 +316,8 @@
       withServerAndClient [MR "VA 3 f2 c7\r\nfoo\r\n", MR "EN\r\n"] $ \server client -> do
         Client.gat client "key" 60 `shouldReturn` Just ("foo", 2, 7)
         Client.gat client "key" 60 `shouldReturn` Nothing
-        mockRequests server `shouldReturn` ["mg key v f c T60\r\n", "mg key v f c T60\r\n"]
+        mockRequests server `shouldReturn`
+          ["version\r\n", "mg key v f c T60\r\n", "mg key v f c T60\r\n"]
 
     it "touches a value" $
       withClient [MR "HD c3\r\n", MR "EN\r\n"] $ \client -> do
@@ -322,7 +327,7 @@
     it "stores and returns the server CAS" $
       withServerAndClient [MR "HD c9\r\n"] $ \server client -> do
         Client.set client "key" "foo" 2 30 `shouldReturn` 9
-        mockRequests server `shouldReturn` ["ms key 3 F2 T30 MS c\r\nfoo\r\n"]
+        mockRequests server `shouldReturn` ["version\r\n", "ms key 3 F2 T30 MS c\r\nfoo\r\n"]
 
     it "reports a set the server did not store" $
       withClient [MR "NS\r\n"] $ \client ->
@@ -345,8 +350,8 @@
         Client.cas client "key" "v" 0 0 2 `shouldReturn` Just 3
         Client.cas client "key" "v" 0 0 2 `shouldReturn` Nothing
         Client.cas client "key" "v" 0 0 2 `shouldReturn` Nothing
-        requests <- mockRequests server
-        requests `shouldSatisfy` all (== "ms key 1 F0 T0 C2 MS c\r\nv\r\n")
+        mockRequests server `shouldReturn`
+          "version\r\n" : replicate 3 "ms key 1 F0 T0 C2 MS c\r\nv\r\n"
 
     it "deletes a present key" $
       withClient [MR "HD\r\n"] $ \client ->
@@ -362,8 +367,8 @@
         Client.get client "key" `shouldThrow` isBadCommand
 
     it "reads version" $
-      withClient [MR "VERSION 1.6.0\r\n"] $ \client ->
-        Client.version client `shouldReturn` "1.6.0"
+      withClient [MR ("VERSION " <> supportedVersion <> "\r\n")] $ \client ->
+        Client.version client `shouldReturn` supportedVersion
 
     it "collects stats until END, keeping values that contain spaces" $
       withClient [MR "STAT curr_items 2\r\nSTAT rusage_user 0.1 0.2\r\nEND\r\n"] $ \client -> do
@@ -374,7 +379,7 @@
       withServerAndClient [MR "END\r\n"] $ \server client -> do
         result <- Client.stats client (Just "cachedump 1 100")
         map snd result `shouldBe` [[]]
-        mockRequests server `shouldReturn` ["stats cachedump 1 100\r\n"]
+        mockRequests server `shouldReturn` ["version\r\n", "stats cachedump 1 100\r\n"]
 
     it "keeps non-STAT stats lines" $
       withClient [MR "ITEM key [3 b; 0 s]\r\nEND\r\n"] $ \client -> do
@@ -388,7 +393,7 @@
     it "returns the new counter value and CAS" $
       withServerAndClient [MR "VA 1 c2\r\n0\r\n"] $ \server client -> do
         Client.decrement client "counter" 10 1 60 0 `shouldReturn` Just (0, 2)
-        mockRequests server `shouldReturn` ["ma counter D1 MD v c N60 J10\r\n"]
+        mockRequests server `shouldReturn` ["version\r\n", "ma counter D1 MD v c N60 J10\r\n"]
 
     it "reports arithmetic on a non-numeric value" $
       withClient [MR "CLIENT_ERROR cannot increment or decrement non-numeric value\r\n"] $ \client ->
@@ -401,12 +406,12 @@
     it "prepends to an existing key" $
       withServerAndClient [MR "HD c4\r\n"] $ \server client -> do
         Client.prepend client "key" "pre" 0 `shouldReturn` Just 4
-        mockRequests server `shouldReturn` ["ms key 3 MP c\r\npre\r\n"]
+        mockRequests server `shouldReturn` ["version\r\n", "ms key 3 MP c\r\npre\r\n"]
 
     it "flushes" $
       withServerAndClient [MR "OK\r\n"] $ \server client -> do
         Client.flush client (Just 10) `shouldReturn` ()
-        mockRequests server `shouldReturn` ["flush_all 10\r\n"]
+        mockRequests server `shouldReturn` ["version\r\n", "flush_all 10\r\n"]
 
     it "reports an oversized value as a status, not a protocol failure" $
       withClient [MR "SERVER_ERROR object too large for cache\r\n"] $ \client ->
@@ -424,9 +429,46 @@
     it "sends quit" $
       withServerAndClient [Noop] $ \server client -> do
         Client.quit client
-        requests <- waitForRequests server 1
-        requests `shouldBe` ["quit\r\n"]
+        requests <- waitForRequests server 2
+        requests `shouldBe` ["version\r\n", "quit\r\n"]
 
+  -- The value is one byte over the 1 GiB limit. In the test of each
+  -- operation, the client's server is a port that is bound but not listening,
+  -- so a client that tried to send the value would throw the refused
+  -- connection instead: the check has to come before the client connects.
+  describe "oversized values" $ beforeAll overLimitValue $ do
+    it "rejects an over-limit value from set without sending anything" $ \value ->
+      withRefusingClient $ \client ->
+        Client.set client "key" value 0 0 `shouldThrow` (== OpError ErrValueTooLarge)
+
+    it "rejects an over-limit value from add without sending anything" $ \value ->
+      withRefusingClient $ \client ->
+        Client.add client "key" value 0 0 `shouldThrow` (== OpError ErrValueTooLarge)
+
+    it "rejects an over-limit value from replace without sending anything" $ \value ->
+      withRefusingClient $ \client ->
+        Client.replace client "key" value 0 0 0 `shouldThrow` (== OpError ErrValueTooLarge)
+
+    it "rejects an over-limit value from cas without sending anything" $ \value ->
+      withRefusingClient $ \client ->
+        Client.cas client "key" value 0 0 1 `shouldThrow` (== OpError ErrValueTooLarge)
+
+    it "rejects an over-limit value from append without sending anything" $ \value ->
+      withRefusingClient $ \client ->
+        Client.append client "key" value 0 `shouldThrow` (== OpError ErrValueTooLarge)
+
+    it "rejects an over-limit value from prepend without sending anything" $ \value ->
+      withRefusingClient $ \client ->
+        Client.prepend client "key" value 0 `shouldThrow` (== OpError ErrValueTooLarge)
+
+    -- This client routes every key to no server, so a value that it lets
+    -- through fails with NoServersReady and is never sent. It still rejects
+    -- the over-limit value, which shows that it checks values first.
+    it "does not reject a value of exactly the limit" $ \value -> do
+      client <- Client.newClient [] Client.def { Client.optsGetServerForKey = \_ _ -> return Nothing }
+      Client.set client "key" value 0 0 `shouldThrow` (== OpError ErrValueTooLarge)
+      Client.set client "key" (B.take valueLimit value) 0 0 `shouldThrow` (== ClientError NoServersReady)
+
   describe "retries and failover" $ do
     let fast = Client.def
           { Client.optsServerTimeout = 300
@@ -437,7 +479,9 @@
     it "retries after the server drops the connection" $
       withServerAndClientOpts fast [CloseConnection, MR "VA 3 f2 c7\r\nfoo\r\n"] $ \server client -> do
         Client.get client "key" `shouldReturn` Just ("foo", 2, 7)
-        length <$> mockRequests server `shouldReturn` 2
+        -- The retry's new connection checks the version again.
+        mockRequests server `shouldReturn`
+          ["version\r\n", "mg key v f c\r\n", "version\r\n", "mg key v f c\r\n"]
 
     it "retries after an operation times out" $
       withServerAndClientOpts fast [DelayMS 350 Noop, MR "VA 3 f2 c7\r\nfoo\r\n"] $ \_ client ->
@@ -447,11 +491,18 @@
       withServerAndClientOpts fast [CloseConnection, CloseConnection, MR "VA 3 f2 c7\r\nfoo\r\n"] $ \server client -> do
         -- The default of two retries means two attempts in total.
         Client.get client "key" `shouldThrow` isUnexpectedEOF
-        length <$> mockRequests server `shouldReturn` 2
+        mockRequests server `shouldReturn`
+          ["version\r\n", "mg key v f c\r\n", "version\r\n", "mg key v f c\r\n"]
         Client.get client "key" `shouldThrow` (== ClientError NoServersReady)
         threadDelay 400000
         Client.get client "key" `shouldReturn` Just ("foo", 2, 7)
 
+    it "checks the version again on the connection a retry opens" $
+      withMockServer [supported, CloseConnection, MR "VERSION 1.6.9\r\n", MR "VA 3 f2 c7\r\nfoo\r\n"] $ \server -> do
+        client <- Client.newClient [mockServerSpec server] fast
+        Client.get client "key" `shouldThrow` refused "VERSION 1.6.9"
+        mockRequests server `shouldReturn` ["version\r\n", "mg key v f c\r\n", "version\r\n"]
+
   describe "authenticate" $ do
     it "accepts credentials once the server confirms auth-file mode" $
       bracket (N.socketPair N.AF_UNIX N.Stream 0) closePair $ \(left, right) -> do
@@ -492,13 +543,104 @@
         [" ", "\t", "\r", "\n"]
 
     it "authenticates each new client connection" $
-      withMockServer [MR "CLIENT_ERROR unauthenticated\r\n", MR "STORED\r\n", MR "VA 3 f2 c7\r\nfoo\r\n"] $ \server -> do
-        let spec = (mockServerSpec server) { ssAuth = Auth.Auth "user" "pass" }
-        client <- Client.newClient [spec] Client.def
+      withMockServer (authExchange ++ [supported, MR "VA 3 f2 c7\r\nfoo\r\n"]) $ \server -> do
+        client <- Client.newClient [withCredentials server] Client.def
         Client.get client "key" `shouldReturn` Just ("foo", 2, 7)
-        mockRequests server `shouldReturn`
-          ["version\r\n", "set auth 0 0 9\r\nuser pass\r\n", "mg key v f c\r\n"]
+        mockRequests server `shouldReturn` authRequests ++ ["version\r\n", "mg key v f c\r\n"]
 
+  -- Older servers don't read the data block of the meta set this client
+  -- sends, so they run the value's bytes as commands. The client must not
+  -- send them anything but its version check (and, with credentials, the
+  -- authentication exchange before it). Each mock has a reply left over for
+  -- a request that should never come, so that one would be recorded.
+  describe "server version check" $ do
+    forM_ oldVersions $ \v ->
+      it ("refuses memcached " <> C.unpack v <> ", sending it nothing but version") $
+        withMockServer [MR ("VERSION " <> v <> "\r\n"), MR "HD c1\r\n"] $ \server -> do
+          client <- Client.newClient [mockServerSpec server] Client.def
+          Client.set client "key" "value" 0 0 `shouldThrow` refused ("VERSION " <> v)
+          mockRequests server `shouldReturn` ["version\r\n"]
+
+    -- Every operation that sends a value, not only set, must be refused
+    -- before the value reaches the server.
+    forM_ valueOps $ \(name, op) ->
+      it ("refuses memcached 1.6.9 for " <> name <> ", sending it nothing but version") $
+        withMockServer [MR "VERSION 1.6.9\r\n", MR "HD c1\r\n"] $ \server -> do
+          client <- Client.newClient [mockServerSpec server] Client.def
+          op client `shouldThrow` refused "VERSION 1.6.9"
+          mockRequests server `shouldReturn` ["version\r\n"]
+
+    forM_ newVersions $ \v ->
+      it ("accepts memcached " <> C.unpack v) $
+        withMockServer [MR ("VERSION " <> v <> "\r\n"), MR "HD c9\r\n"] $ \server -> do
+          client <- Client.newClient [mockServerSpec server] Client.def
+          Client.set client "key" "value" 0 0 `shouldReturn` 9
+          mockRequests server `shouldReturn` ["version\r\n", "ms key 5 F0 T0 MS c\r\nvalue\r\n"]
+
+    forM_ unreadableReplies $ \reply ->
+      it ("refuses a server that answers version with " <> show reply) $
+        withMockServer [MR (reply <> "\r\n"), MR "HD c1\r\n"] $ \server -> do
+          client <- Client.newClient [mockServerSpec server] Client.def
+          Client.set client "key" "value" 0 0 `shouldThrow` refused reply
+          mockRequests server `shouldReturn` ["version\r\n"]
+
+    -- Such as a server in auth-file mode, when the client has no credentials.
+    it "throws a CLIENT_ERROR reply to version as it would for any request" $
+      withMockServer [MR "CLIENT_ERROR unauthenticated\r\n", MR "HD c1\r\n"] $ \server -> do
+        client <- Client.newClient [mockServerSpec server] Client.def
+        Client.set client "key" "value" 0 0
+          `shouldThrow` (== ProtocolError (E.BadCommand "unauthenticated"))
+        mockRequests server `shouldReturn` ["version\r\n"]
+
+    it "throws an ERROR reply to version as it would for any request" $
+      withMockServer [MR "ERROR\r\n", MR "HD c1\r\n"] $ \server -> do
+        client <- Client.newClient [mockServerSpec server] Client.def
+        Client.set client "key" "value" 0 0 `shouldThrow` (== ProtocolError (UnknownOp "ERROR"))
+        mockRequests server `shouldReturn` ["version\r\n"]
+
+    -- A server failure is retried, as it would be for any request, but each
+    -- attempt still sends nothing but version.
+    it "throws a SERVER_ERROR reply to version as it would for any request" $
+      withMockServer [MR "SERVER_ERROR busy\r\n", MR "SERVER_ERROR busy\r\n", MR "HD c1\r\n"] $ \server -> do
+        client <- Client.newClient [mockServerSpec server] Client.def { Client.optsFailRetryDelay = 10 }
+        Client.set client "key" "value" 0 0 `shouldThrow` (== ProtocolError (E.ServerError "busy"))
+        mockRequests server `shouldReturn` ["version\r\n", "version\r\n"]
+
+    -- The server's version won't change on a retry: a refusal is a client
+    -- fault, so the operation fails at once and the server stays alive.
+    it "neither retries a refused server nor marks it dead" $
+      withMockServer [MR "VERSION 1.6.9\r\n", MR "VERSION 1.6.9\r\n", MR "HD c1\r\n", MR "HD c1\r\n"] $ \server -> do
+        client <- Client.newClient [mockServerSpec server] Client.def
+        Client.set client "key" "value" 0 0 `shouldThrow` refused "VERSION 1.6.9"
+        mockRequests server `shouldReturn` ["version\r\n"]
+        -- A server marked dead would fail with NoServersReady without being
+        -- asked again.
+        Client.get client "key" `shouldThrow` refused "VERSION 1.6.9"
+        mockRequests server `shouldReturn` ["version\r\n", "version\r\n"]
+
+    describe "with credentials" $ do
+      forM_ oldVersions $ \v ->
+        it ("asks again after authenticating, and refuses memcached " <> C.unpack v) $
+          withMockServer (authExchange ++ [MR ("VERSION " <> v <> "\r\n"), MR "HD c1\r\n"]) $ \server -> do
+            client <- Client.newClient [withCredentials server] Client.def
+            Client.set client "key" "value" 0 0 `shouldThrow` refused ("VERSION " <> v)
+            mockRequests server `shouldReturn` authRequests ++ ["version\r\n"]
+
+      forM_ newVersions $ \v ->
+        it ("asks again after authenticating, and accepts memcached " <> C.unpack v) $
+          withMockServer (authExchange ++ [MR ("VERSION " <> v <> "\r\n"), MR "HD c9\r\n"]) $ \server -> do
+            client <- Client.newClient [withCredentials server] Client.def
+            Client.set client "key" "value" 0 0 `shouldReturn` 9
+            mockRequests server `shouldReturn`
+              authRequests ++ ["version\r\n", "ms key 5 F0 T0 MS c\r\nvalue\r\n"]
+
+      forM_ unreadableReplies $ \reply ->
+        it ("refuses a server that answers version with " <> show reply <> " after authenticating") $
+          withMockServer (authExchange ++ [MR (reply <> "\r\n"), MR "HD c1\r\n"]) $ \server -> do
+            client <- Client.newClient [withCredentials server] Client.def
+            Client.set client "key" "value" 0 0 `shouldThrow` refused reply
+            mockRequests server `shouldReturn` authRequests ++ ["version\r\n"]
+
   describe "server URIs" $ do
     it "parses host and port" $
       parseServerSpec "memcached://cache.example:1234" `shouldBe`
@@ -526,8 +668,8 @@
 
   describe "clusters" $ do
     it "fails over to another server once one is marked dead" $
-      withMockServer [MR "VA 1 f0 c1\r\nA\r\n", CloseConnection, CloseConnection] $ \a ->
-      withMockServer [MR "VA 1 f0 c1\r\nB\r\n", CloseConnection, CloseConnection] $ \b -> do
+      withMockMemcached supportedVersion [MR "VA 1 f0 c1\r\nA\r\n", CloseConnection, CloseConnection] $ \a ->
+      withMockMemcached supportedVersion [MR "VA 1 f0 c1\r\nB\r\n", CloseConnection, CloseConnection] $ \b -> do
         client <- Client.newClient [mockServerSpec a, mockServerSpec b] fastFailover
         first <- Client.get client "key"
         -- The server that answered now drops two connections in a row, which
@@ -538,7 +680,7 @@
         map (fmap fst3) [first, second] `shouldSatisfy` (`elem` [[Just "A", Just "B"], [Just "B", Just "A"]])
 
     it "throws NoServersReady once every server is dead" $
-      withMockServer [CloseConnection, CloseConnection] $ \a -> do
+      withMockMemcached supportedVersion [CloseConnection, CloseConnection] $ \a -> do
         client <- Client.newClient [mockServerSpec a] fastFailover
         Client.get client "key" `shouldThrow` isUnexpectedEOF
         Client.get client "key" `shouldThrow` (== ClientError NoServersReady)
@@ -546,49 +688,56 @@
         Client.version client `shouldThrow` (== ClientError NoServersReady)
 
     it "flushes every server" $
-      withMockServer [MR "OK\r\n"] $ \a ->
-      withMockServer [MR "OK\r\n"] $ \b -> do
+      withMockMemcached supportedVersion [MR "OK\r\n"] $ \a ->
+      withMockMemcached supportedVersion [MR "OK\r\n"] $ \b -> do
         client <- Client.newClient [mockServerSpec a, mockServerSpec b] Client.def
         Client.flush client Nothing
-        mockRequests a `shouldReturn` ["flush_all\r\n"]
-        mockRequests b `shouldReturn` ["flush_all\r\n"]
+        mockRequests a `shouldReturn` ["version\r\n", "flush_all\r\n"]
+        mockRequests b `shouldReturn` ["version\r\n", "flush_all\r\n"]
 
     it "collects stats from every server" $
-      withMockServer [MR "STAT pid 1\r\nEND\r\n"] $ \a ->
-      withMockServer [MR "STAT pid 2\r\nEND\r\n"] $ \b -> do
+      withMockMemcached supportedVersion [MR "STAT pid 1\r\nEND\r\n"] $ \a ->
+      withMockMemcached supportedVersion [MR "STAT pid 2\r\nEND\r\n"] $ \b -> do
         client <- Client.newClient [mockServerSpec a, mockServerSpec b] Client.def
         results <- Client.stats client Nothing
         concatMap snd results `shouldMatchList` [("pid", "1"), ("pid", "2")]
 
     it "asks a single server for the version" $
-      withMockServer [MR "VERSION 1.6.1\r\n"] $ \a ->
-      withMockServer [MR "VERSION 1.6.1\r\n"] $ \b -> do
+      withMockMemcached supportedVersion [supported] $ \a ->
+      withMockMemcached supportedVersion [supported] $ \b -> do
         client <- Client.newClient [mockServerSpec a, mockServerSpec b] Client.def
-        Client.version client `shouldReturn` "1.6.1"
-        requests <- (++) <$> mockRequests a <*> mockRequests b
-        requests `shouldBe` ["version\r\n"]
+        Client.version client `shouldReturn` supportedVersion
+        -- The connection's own version check, then the operation.
+        requests <- sequence [mockRequests a, mockRequests b]
+        requests `shouldMatchList` [["version\r\n", "version\r\n"], []]
 
   describe "ElastiCache discovery" $ do
     it "rejects an endpoint that is not a configuration endpoint" $
       isLeft (EC.parseConfigurationEndpoint "memcached://cache.example:11211") `shouldBe` True
 
     it "discovers nodes with the config command" $
-      withMockServer [MR "VA 3 f0 c1\r\nfoo\r\n"] $ \node -> do
+      withMockMemcached supportedVersion [MR "VA 3 f0 c1\r\nfoo\r\n"] $ \node -> do
         let config = "CONFIG cluster 0 " <> nodeList node <> "END\r\n"
-        withMockServer [MR "VERSION 1.6.12\r\n", MR config, Noop] $ \cfg -> do
-          client <- EC.newClient Client.def hour (endpoint cfg)
+        withMockMemcached "1.6.12" [MR "VERSION 1.6.12\r\n", MR config, Noop] $ \cfg -> do
+          client <- inTime (EC.newClient Client.def hour (endpoint cfg))
           Client.get client "key" `shouldReturn` Just ("foo", 0, 1)
-          waitForRequests cfg 3 `shouldReturn`
-            ["version\r\n", "config get cluster\r\n", "quit\r\n"]
+          -- The connection's own version check, then discovery's.
+          waitForRequests cfg 4 `shouldReturn`
+            ["version\r\n", "version\r\n", "config get cluster\r\n", "quit\r\n"]
 
-    it "discovers nodes from the cluster key on engines before 1.4.14" $
+    -- Engines before 1.4.14 keep the node list in a key, which discovery
+    -- used to read with a plain get. Like any server older than memcached
+    -- 1.6.10, they are now refused before discovery sends anything.
+    it "refuses a configuration endpoint older than memcached 1.6.10" $
       withMockServer [MR "VA 3 f0 c1\r\nfoo\r\n"] $ \node -> do
         let value = "VALUE AmazonElastiCache:cluster 0 " <> nodeList node <> "END\r\n"
         withMockServer [MR "VERSION 1.4.5\r\n", MR value, Noop] $ \cfg -> do
-          client <- EC.newClient Client.def hour (endpoint cfg)
-          Client.get client "key" `shouldReturn` Just ("foo", 0, 1)
-          waitForRequests cfg 3 `shouldReturn`
-            ["version\r\n", "get AmazonElastiCache:cluster\r\n", "quit\r\n"]
+          inTime (EC.newClient Client.def hour (endpoint cfg)) `shouldThrow` refused "VERSION 1.4.5"
+          -- Discovery's connection is refused after asking for the version.
+          -- Quitting its client then opens another, which the mock answers
+          -- with the node list; that is no version either, so it is refused
+          -- too.
+          mockRequests cfg `shouldReturn` ["version\r\n", "version\r\n"]
 
   where
     recvResponseFrom bytes =
@@ -623,7 +772,38 @@
     allStats [(_, [ ("curr_items", "2"), ("rusage_user", "0.1 0.2") ])] = True
     allStats _ = False
     expectedAuthRequests = "version\r\nset auth 0 0 9\r\nuser pass\r\n"
+    -- A server in auth-file mode rejects the client's first version request,
+    -- then accepts its credentials.
+    authExchange = [MR "CLIENT_ERROR unauthenticated\r\n", MR "STORED\r\n"]
+    authRequests = ["version\r\n", "set auth 0 0 9\r\nuser pass\r\n"]
+    withCredentials server = (mockServerSpec server) { ssAuth = Auth.Auth "user" "pass" }
+    supported = MR ("VERSION " <> supportedVersion <> "\r\n")
+    -- Versions as memcached reports them, with Ubuntu's suffix and a
+    -- release candidate's; 1.10.0 and 1.6.9 catch comparing them as text.
+    oldVersions =
+      ["1.6.9", "1.5.22", "1.4.25", "1.6.0", "1.4.25 Ubuntu", "1.6.9-rc1", "0.10.10"]
+    newVersions =
+      ["1.6.10", "1.6.14", "1.6.24", "1.6.100", "1.7.0", "1.10.0", "2.0.0", "1.6.10-rc1", "1.6.24 Ubuntu"]
+    unreadableReplies =
+      [ "VERSION", "VERSION 1.6", "VERSION 1.7", "VERSION 1.6.x", "VERSION v1.6.24"
+      , "VERSION 1..6.24", "VERSION 1.6.+10", "VERSION -1.6.24", "HD", "END", "HD 1.6.24" ]
+    -- The operations that send a value, each storing one that would run as
+    -- a command on a server older than 1.6.10.
+    valueOps :: [(String, Client.Client -> IO ())]
+    valueOps =
+      [ ("set",     \c -> void $ Client.set c "key" injection 0 0)
+      , ("add",     \c -> void $ Client.add c "key" injection 0 0)
+      , ("replace", \c -> void $ Client.replace c "key" injection 0 0 0)
+      , ("cas",     \c -> void $ Client.cas c "key" injection 0 0 1)
+      , ("append",  \c -> void $ Client.append c "key" injection 0)
+      , ("prepend", \c -> void $ Client.prepend c "key" injection 0)
+      ]
+    injection :: B.ByteString
+    injection = "set injected 0 0 3\r\nbad"
     fastFailover = Client.def { Client.optsFailRetryDelay = 10, Client.optsDeadRetryDelay = 60000 }
+    -- Discovery has no timeout of its own, so a client that sent the mock
+    -- something it has no reply for would wait for one forever.
+    inTime action = timeout 2000000 action >>= maybe (fail "timed out") return
     fst3 (value, _, _) = value
     hour = 3600 * 1000000
     -- The endpoint check only looks for ".cfg" somewhere in the URI, so put it
@@ -635,7 +815,8 @@
       let body = "1\n127.0.0.1|127.0.0.1|" <> C.pack (show (mockPort node)) <> "\n"
       in C.pack (show (B.length body)) <> "\r\n" <> body <> "\r\n"
 
--- | Run an action with a client connected to a fresh mock server.
+-- | Run an action with a client connected to a fresh mock server, which
+-- reports 'supportedVersion' to each connection's version check.
 withClient :: [MockResponse] -> (Client.Client -> IO a) -> IO a
 withClient responses action = withServerAndClient responses (const action)
 
@@ -644,9 +825,46 @@
 
 withServerAndClientOpts
   :: Client.Options -> [MockResponse] -> (MockServer -> Client.Client -> IO a) -> IO a
-withServerAndClientOpts opts responses action = withMockServer responses $ \server -> do
+withServerAndClientOpts opts responses action = withMockMemcached supportedVersion responses $ \server -> do
   client <- Client.newClient [mockServerSpec server] opts
   action server client
+
+-- | The version that mock servers report unless a test says otherwise: one
+-- the client accepts.
+supportedVersion :: B.ByteString
+supportedVersion = "1.6.24"
+
+-- | Whether an exception is the client refusing a server that answered its
+-- version check with the given reply: 'UnknownOp', with a message that quotes
+-- the reply and names the minimum version.
+refused :: B.ByteString -> MemcacheError -> Bool
+refused reply (ProtocolError (UnknownOp message)) =
+  show reply `isInfixOf` message && "1.6.10 or later" `isInfixOf` message
+refused _ _ = False
+
+-- | Run an action with a client whose server is a port on 127.0.0.1 that is
+-- bound but not listening, so every attempt to connect to it is refused.
+withRefusingClient :: (Client.Client -> IO a) -> IO a
+withRefusingClient action =
+  bracket (N.socket N.AF_INET N.Stream N.defaultProtocol) N.close $ \sock -> do
+    N.bind sock (N.SockAddrInet 0 (N.tupleToHostAddress (127, 0, 0, 1)))
+    port <- N.socketPort sock
+    client <- Client.newClient [ServerSpec "127.0.0.1" (show port) Auth.NoAuth] Client.def
+    action client
+
+-- | The largest value memcached can store, 1 GiB.
+valueLimit :: Int
+valueLimit = 1024 * 1024 * 1024
+
+-- | A value one byte longer than 'valueLimit'. It is malloc'd outside the GHC
+-- heap and never written, and the client reads only its length, so it takes
+-- next to no memory, unless malloc fills it, as glibc's does when
+-- MALLOC_PERTURB_ is set. It is freed once nothing refers to it.
+overLimitValue :: IO B.ByteString
+overLimitValue = do
+  let len = valueLimit + 1
+  ptr <- mallocBytes len
+  unsafePackMallocCStringLen (ptr, len)
 
 -- | Wait (up to a second) for the mock to have received at least @n@ requests.
 waitForRequests :: MockServer -> Int -> IO [B.ByteString]
