Index: src/XrdProofdProofServMgr.cxx
===================================================================
--- src/XrdProofdProofServMgr.cxx	(revision 44700)
+++ src/XrdProofdProofServMgr.cxx	(working copy)
@@ -144,21 +144,7 @@
             TRACE(REQ, "kSessionRemoval: session: "<<fpid<<
                         " has been removed from the active list");
          } else if (msg.Type() == XrdProofdProofServMgr::kClientDisconnect) {
-            // A client just disconnected: we free the slots in the proofserv sesssions and
-            // we check the sessions status to see if any of them must be terminated
-            // read process id
-            int pid = 0;
-            if ((rc = msg.Get(pid)) != 0) {
-               TRACE(XERR, "kClientDisconnect: problems receiving process ID (buf: '"<<
-                           msg.Buf()<<"'); errno: "<<-rc);
-               continue;
-            }
-            TRACE(REQ, "kClientDisconnect: a client just disconnected: "<<pid);
-            // Free slots in the proof serv instances
-            mgr->DisconnectFromProofServ(pid);
-            TRACE(DBG, "quick check of active sessions");
-            // Quick check of active sessions in case of disconnections
-            mgr->CheckActiveSessions(0);
+            // obsolete
         } else if (msg.Type() == XrdProofdProofServMgr::kCleanSessions) {
             // Request for cleanup all sessions of a client (or all clients)
             XpdSrvMgrCreateCnt cnt(mgr, XrdProofdProofServMgr::kCleanSessionsCnt);
Index: src/XrdProofdProtocol.cxx
===================================================================
--- src/XrdProofdProtocol.cxx	(revision 44700)
+++ src/XrdProofdProtocol.cxx	(working copy)
@@ -736,15 +736,35 @@
 
    if (pmgr) {
 
-
       if (!Internal()) {
 
-         // Signal the client manager that a client has just gone
-         if (fgMgr && fgMgr->ClientMgr()) {
-            TRACE(HDBG, "fAdminPath: "<<fAdminPath);
-            XPDFORM(buf, "%s %p %d %d", fAdminPath.c_str(), pmgr, fCID, fPid);
-            TRACE(DBG, "sending to ClientMgr: "<<buf);
-            fgMgr->ClientMgr()->Pipe()->Post(XrdProofdClientMgr::kClientDisconnect, buf.c_str());
+         TRACE(REQ,"External disconnection of protocol associated with pid "<<fPid);
+
+         // Write disconnection file
+         XrdOucString discpath(fAdminPath, 0, fAdminPath.rfind("/cid"));
+         discpath += "/disconnected";
+         FILE *fd = fopen(discpath.c_str(), "w");
+            if (!fd) {
+            TRACE(XERR, "unable to create path: " <<discpath);
+         } else {
+            fclose(fd);  
+         } 
+
+         // Remove protocol and response from attached client/proofserv instances
+	 // Set reconnect flag if proofserv instances attached to this client are still running
+         pmgr->ResetClientSlot(fCID);
+         if(fgMgr && fgMgr->SessionMgr()) {
+            XrdSysMutexHelper mhp(fgMgr->SessionMgr()->Mutex());
+
+            fgMgr->SessionMgr()->DisconnectFromProofServ(fPid);
+            if(pmgr->Running()) {
+	       TRACE(REQ,"Non-idle proofserv processes attached to this client, setting reconnect time");
+	       fgMgr->SessionMgr()->SetReconnectTime(true);
+            }
+            fgMgr->SessionMgr()->CheckActiveSessions(0);
+	 }
+         else {
+	    TRACE(XERR,"No XrdProofdMgr ("<<fgMgr<<") or SessionMgr ("<<fgMgr->SessionMgr()<<")")
          }
 
       } else {
@@ -753,11 +773,16 @@
          // of proxy servers and to notify the attached clients.
          // Tell the session manager that this session has gone
          if (fgMgr && fgMgr->SessionMgr()) {
+            XrdSysMutexHelper mhp(fgMgr->SessionMgr()->Mutex());
             TRACE(HDBG, "fAdminPath: "<<fAdminPath);
             buf.assign(fAdminPath, fAdminPath.rfind('/') + 1, -1);
-            TRACE(DBG, "sending to ProofServMgr: "<<buf);
-            fgMgr->SessionMgr()->Pipe()->Post(XrdProofdProofServMgr::kSessionRemoval, buf.c_str());
+            fgMgr->SessionMgr()->DeleteFromSessions(buf.c_str());
+            // Move the entry to the terminated sessions area
+            fgMgr->SessionMgr()->MvSession(buf.c_str());
          }
+         else {
+	    TRACE(XERR,"No XrdProofdMgr ("<<fgMgr<<") or SessionMgr ("<<fgMgr->SessionMgr()<<")")
+         }
       }
    }
 
Index: src/XrdProofdClient.cxx
===================================================================
--- src/XrdProofdClient.cxx	(revision 44700)
+++ src/XrdProofdClient.cxx	(working copy)
@@ -34,7 +34,7 @@
 
 //__________________________________________________________________________
 XrdProofdClient::XrdProofdClient(XrdProofUI ui, bool master, bool changeown,
-                                 XrdSysError *, const char *adminpath)
+                                 XrdSysError *, const char *adminpath, int rtime)
                 : fSandbox(ui, master, changeown)
 {
    // Constructor
@@ -48,6 +48,7 @@
    fAskedToTouch = 0;
    fChangeOwn = changeown;
    fLauncher = 0;
+   fReconnectTimeOut = rtime;
 
    // Make sure the admin path exists
    XPDFORM(fAdminPath, "%s/%s.%s", adminpath, ui.fUser.c_str(), ui.fGroup.c_str());
@@ -104,6 +105,11 @@
       // Search for free places in the existing vector
       for (ic = 0; ic < (int)fClients.size() ; ic++) {
          if (fClients[ic] && !fClients[ic]->IsValid()) {
+            int rtime = fClients[ic]->ResetTime();
+            if ((rtime >= 0) && ((time(0) - rtime) < fReconnectTimeOut)) {
+               // The session using this cid disconnected too recently, do not reuse yet
+               continue;
+            }
             cid = fClients[ic];
             cid->Reset();
             break;
@@ -388,7 +394,7 @@
 //______________________________________________________________________________
 XrdProofdProtocol *XrdProofdClient::GetProtocol(int ic)
 {
-   // Reset slot at 'ic'
+   // Return protocol attached to client slot at 'ic'
    XPDLOC(CMGR, "Client::GetProtocol")
 
    TRACE(DBG, "enter: ic: " << ic);
@@ -627,6 +633,24 @@
 }
 
 //______________________________________________________________________________
+bool XrdProofdClient::Running()
+{
+   // Check status of attached proofservs
+
+   XrdSysMutexHelper mh(fMutex);
+
+   int is = 0; bool running = false;
+   XrdProofdProofServ *s = 0;
+   for (is = 0; is < (int) fProofServs.size(); is++) {
+      if ((s = fProofServs.at(is)) && s->IsValid()) {
+	 if(!running && (s->Status()!=kXPD_idle)) running = true;
+      }
+   }
+
+   return running;
+}
+
+//______________________________________________________________________________
 void XrdProofdClient::TerminateSessions(int srvtype, XrdProofdProofServ *ref,
                                         const char *msg, XrdProofdPipe *pipe,
                                         bool changeown)
Index: src/XrdProofdClientMgr.cxx
===================================================================
--- src/XrdProofdClientMgr.cxx	(revision 44700)
+++ src/XrdProofdClientMgr.cxx	(working copy)
@@ -71,7 +71,7 @@
       return (void *)0;
    }
    XrdProofdProofServMgr *smgr = mc->fSessionMgr;
-   if (!(mgr)) {
+   if (!(smgr)) {
       TRACE(REQ, "undefined session manager: cannot start");
       return (void *)0;
    }
@@ -93,45 +93,10 @@
             continue;
          }
          // Parse type
-         XrdOucString buf;
+         //XrdOucString buf;
          if (msg.Type() == XrdProofdClientMgr::kClientDisconnect) {
-            // Read admin path and pointer to the client instance
-            XrdOucString adminpath;
-            rc = msg.Get(adminpath);
-            void *cp = 0;
-            rc = (rc == 0) ? msg.Get(&cp) : rc;
-            XrdProofdClient *c = (XrdProofdClient *)cp;
-            int cid = -1;
-            rc = (rc == 0) ? msg.Get(cid) : rc;
-            int pid = -1;
-            rc = (rc == 0) ? msg.Get(pid) : rc;
-            if (rc != 0) {
-               TRACE(XERR, "kClientDisconnect: problems parsing message: '"<<
-                           msg.Buf()<<"'; errno: "<<-rc);
-               continue;
-            }
-            TRACE(DBG, "kClientDisconnect: got: '"<<adminpath<<"', "<<c<<", "<<cid);
-            if (c) {
-               // Reset the corresponding client slot in the list of this client
-               c->ResetClientSlot(cid);
-            } else {
-               TRACE(XERR, "kClientDisconnect: problems getting pointer to client instance: "<<c);
-            }
-
-            // Remove the client admin path
-            if (adminpath != "????") {
-               adminpath.erase(adminpath.rfind("/cid"));
-               if ((rc = XrdProofdAux::RmDir(adminpath.c_str())) != 0) {
-                  TRACE(XERR, "kClientDisconnect: problems removing admin path; errno: "<<-rc);
-                  continue;
-               }
-            }
-
-            // Tell the session manager that a client has gone
-            XPDFORM(buf, "%d", pid);
-            smgr->Pipe()->Post(XrdProofdProofServMgr::kClientDisconnect, buf.c_str());
-            TRACE(DBG,"sending to ProofServMgr: "<<buf);
-
+            // obsolete
+	    TRACE(XERR, "obsolete type: XrdProofdClientMgr::kClientDisconnect");
          } else {
             TRACE(XERR, "unknown type: "<<msg.Type());
             continue;
@@ -724,7 +689,7 @@
             TRACEP(p, XERR, msg.c_str());
          }
          // Update counters
-         fNDisconnected--;
+         if(fNDisconnected) fNDisconnected--;
 
       } else {
          // The index of the next free slot will be the unique ID
@@ -816,12 +781,16 @@
    // Create the path now
    XPDFORM(cidpath, "%s/%s/cid", p->Client()->AdminPath(), lid.c_str());
 
-   // Check last access time
-   int rc = 0;
+   // Create disconnected path
+   XrdOucString discpath;
+   XPDFORM(discpath, "%s/%s/disconnected", p->Client()->AdminPath(), lid.c_str());
+
+   // Check last access time of disconnected if available, otherwise cid
    bool expired = false;
    struct stat st;
-   if ((rc = stat(cidpath.c_str(), &st)) != 0 ||
-       (expired = ((int)(time(0) - st.st_atime) > fReconnectTimeOut))) {
+   int rc = stat(discpath.c_str(), &st);
+   if (rc != 0) rc = stat(cidpath.c_str(), &st);
+   if (rc != 0 || (expired = ((int)(time(0) - st.st_atime) > fReconnectTimeOut))) {
       if (expired || (rc != 0 && errno != ENOENT)) {
          // Remove the file
          cidpath.replace("/cid", "");
@@ -1020,13 +989,6 @@
                            // during last cycle and it did not do it, so we close
                            // the link
                            xclose = 1;
-                           // This clients looks like disconnected
-                           FILE *fd = fopen(discpath.c_str(), "w");
-                           if (!fd) {
-                              TRACE(XERR, "unable to create path: " <<discpath);
-                           } else {
-                              fclose(fd);
-                           }
                         }
                      }
                   }
@@ -1034,14 +996,6 @@
                   // No id info, clean
                   xrm = 1;
                }
-               // If too old remove the entry
-               if (xrm) {
-                  discpath.replace("/disconnected", "");
-                  TRACE(DBG, "removing path "<<discpath);
-                  if ((rc = XrdProofdAux::RmDir(discpath.c_str())) != 0) {
-                     TRACE(XERR, "problems removing "<<discpath<<"; error: "<<-rc);
-                  }
-               }
                // If inactive since too long, close the associated link
                if (xclose) {
                   // Get the client id
@@ -1058,11 +1012,15 @@
                         p->Link()->Close();
                      } else {
                         TRACE(XERR, "protocol or link associated with ID "<<cid<<" are invalid");
+                        xrm = 1;
                      }
                   } else {
                      TRACE(XERR, "could not resolve client id from "<<cidpath);
+                     xrm = 1;
                   }
-
+               }
+               // If too old remove the entry
+               if (xrm) {
                   discpath.replace("/disconnected", "");
                   TRACE(DBG, "removing path "<<discpath);
                   if ((rc = XrdProofdAux::RmDir(discpath.c_str())) != 0) {
@@ -1390,7 +1348,7 @@
          ui.fUser = usr;
          ui.fGroup = grp;
          bool full = (fMgr->SrvType() != kXPD_Worker)  ? 1 : 0;
-         c = new XrdProofdClient(ui, full, fMgr->ChangeOwn(), fEDest, fClntAdminPath.c_str());
+         c = new XrdProofdClient(ui, full, fMgr->ChangeOwn(), fEDest, fClntAdminPath.c_str(), fReconnectTimeOut);
          newclient = 1;
          bool freeclient = 1;
          if (c && c->IsValid()) {
Index: src/XrdProofdProofServ.cxx
===================================================================
--- src/XrdProofdProofServ.cxx	(revision 44700)
+++ src/XrdProofdProofServ.cxx	(working copy)
@@ -341,7 +341,12 @@
       for (i = fClients.begin(); i != fClients.end(); ++i) {
          if ((*i) && (*i)->P()) {
             if ((*i)->P()->Pid() == pid || (*i)->P()->Pid() == -1) {
+               if (fProtocol == (*i)->P()) {
+                  SetProtocol(0);
+                  SetConnection(0);
+               }
                (*i)->Reset();
+               if (fParent == (*i)) SetParent(0);
                fNClients--;
                // Record time of last disconnection
                if (fNClients <= 0)
Index: inc/XrdProofdClient.h
===================================================================
--- inc/XrdProofdClient.h	(revision 44700)
+++ inc/XrdProofdClient.h	(working copy)
@@ -45,7 +45,7 @@
 
  public:
    XrdProofdClient(XrdProofUI ui,
-                   bool master, bool changeown, XrdSysError *edest, const char *tmp);
+                   bool master, bool changeown, XrdSysError *edest, const char *tmp, int rtime);
 
    virtual ~XrdProofdClient();
 
@@ -74,6 +74,8 @@
 
    void                    Broadcast(const char *msg);
 
+   bool                    Running();
+
    XrdOucString            ExportSessions(XrdOucString &emsg, XrdProofdResponse *r = 0);
    void                    SkipSessionsCheck(std::list<XrdProofdProofServ *> *active,
                                              XrdOucString &emsg, XrdProofdResponse *r = 0);
@@ -105,6 +107,7 @@
    bool                    fChangeOwn; // TRUE if ownership must be changed where relevant
    bool                    fIsValid; // TRUE if the instance is complete
    bool                    fAskedToTouch; // TRUE if a touch request has already been sent for this client
+   int                     fReconnectTimeOut; // Time given for disconnected clients to reconnect
 
    XrdProofUI              fUI;         // user info
    XrdROOT                *fROOT;        // ROOT vers instance to be used for proofserv
@@ -133,18 +136,20 @@
    XrdProofdProtocol *fP;
    XrdProofdResponse *fR;
    unsigned short     fSid;
+   int                fResetTime;
 
    void               SetR() { fR = (fP && fSid > 0) ? fP->Response(fSid) : 0;}
 public:
    XrdClientID(XrdProofdProtocol *pt = 0, unsigned short id = 0)
-            { fP = pt; fSid = id; SetR();}
+            { fP = pt; fSid = id; SetR(); fResetTime = -1; }
    ~XrdClientID() { }
 
    XrdProofdClient   *C() const { return fP->Client(); }
    bool               IsValid() const { return (fP != 0); }
    XrdProofdProtocol *P() const { return fP; }
    XrdProofdResponse *R() const { return fR; }
-   void               Reset() { fP = 0; fSid = 0; SetR(); }
+   void               Reset() { fP = 0; fSid = 0; SetR(); fResetTime = time(0); }
+   int                ResetTime() { return fResetTime; }
    void               SetP(XrdProofdProtocol *p) { fP = p; SetR();}
    void               SetSid(unsigned short sid) { fSid = sid; SetR();}
    unsigned short     Sid() const { return fSid; }