Beispiel #1
0
 /* package */
 Object getReply() {
   Object msg;
   if (replies == null) {
     return null;
   }
   synchronized (replies) {
     // Test and remove must be atomic
     if (replies.isEmpty()) {
       if (Debug.LDAP_DEBUG) {
         Debug.trace(Debug.messages, name + "No replies queued for message");
       }
       return null; // No data
     }
     msg = replies.remove(0); // Atomic get and remove
   }
   if (Debug.LDAP_DEBUG) {
     Debug.trace(
         Debug.messages, name + "Got reply from queue(" + replies.size() + " remaining in queue)");
   }
   if ((conn != null) && (complete || !acceptReplies) && replies.isEmpty()) {
     // Remove msg from connection queue when last reply read
     conn.removeMessage(this);
   }
   return msg;
 }
Beispiel #2
0
 /* package */
 Object waitForReply() {
   if (Debug.LDAP_DEBUG) {
     Debug.trace(Debug.messages, name + "waitForReply()");
   }
   if (replies == null) {
     return null;
   }
   // sync on message so don't confuse with timer thread
   synchronized (replies) {
     Object msg = null;
     while (waitForReply) {
       if (replies.isEmpty()) {
         if (Debug.LDAP_DEBUG) {
           Debug.trace(Debug.messages, name + "No replies queued, waitForReply=" + waitForReply);
         }
         try {
           if (Debug.LDAP_DEBUG) {
             Debug.trace(Debug.messages, name + "Wait for a reply");
           }
           replies.wait();
         } catch (InterruptedException ir) {; // do nothing
         }
         if (waitForReply) {
           continue;
         } else {
           break;
         }
       } else {
         msg = replies.remove(0); // Atomic get and remove
       }
       if ((complete || !acceptReplies) && replies.isEmpty()) {
         // Remove msg from connection queue when last reply read
         conn.removeMessage(this);
         if (Debug.LDAP_DEBUG) {
           Debug.trace(Debug.messages, name + "Last message removed, remove msg from Connection");
         }
       } else {
         if (Debug.LDAP_DEBUG) {
           Debug.trace(
               Debug.messages,
               name + "Got reply from queue(" + replies.size() + " remaining in queue)");
         }
       }
       return msg;
     }
     return null;
   }
 }
Beispiel #3
0
 /** Release reply messages */
 private void cleanup() {
   if (Debug.LDAP_DEBUG) {
     Debug.trace(Debug.messages, name + "cleanup");
   }
   stopTimer(); // Make sure timer stopped
   try {
     acceptReplies = false;
     if (conn != null) {
       conn.removeMessage(this);
     }
     // Empty out any accumuluated replies
     if (replies != null) {
       if (Debug.LDAP_DEBUG) {
         if (!replies.isEmpty()) {
           Debug.trace(Debug.messages, name + "cleanup: remove " + replies.size() + " replies");
         }
       }
       while (!replies.isEmpty()) {
         replies.remove(0);
       }
     }
   } catch (Throwable ex) {
     if (Debug.LDAP_DEBUG) {
       Debug.trace(Debug.messages, name + "cleanup exception:" + ex.toString());
     }
     ; // nothing
   }
   // Let GC clean up this stuff, leave name in case finalized is called
   conn = null;
   msg = null;
   // agent = null;  // leave this reference
   queue = null;
   // replies = null; //leave this since we use it as a semaphore
   bindprops = null;
   return;
 }
Beispiel #4
0
  /* package */
  void abandon(LDAPConstraints cons, InterThreadException informUserEx) {
    if (!waitForReply) {
      Debug.trace(Debug.messages, name + "Abandon request ignored");
      return;
    }
    if (Debug.LDAP_DEBUG) {
      Debug.trace(
          Debug.messages,
          name
              + "Abandon request, complete="
              + complete
              + ", bind="
              + (bindprops != null)
              + ", informUser="******", waitForReply="
              + waitForReply);
    }
    acceptReplies = false; // don't listen to anyone
    waitForReply = false; // don't let sleeping threads lie
    if (!complete) {
      try {
        // If a bind, release bind semaphore & wake up waiting threads
        // Must do before writing abandon message, otherwise deadlock
        if (bindprops != null) {
          int id;
          if (conn.isBindSemIdClear()) {
            // Semaphore id for normal operations
            id = msgId;
          } else {
            // Semaphore id for sasl bind
            id = conn.getBindSemId();
            conn.clearBindSemId();
          }
          conn.freeWriteSemaphore(id);
        }

        if (Debug.LDAP_DEBUG) {
          Debug.trace(Debug.messages, name + "Sending abandon request");
        }
        // Create the abandon message, but don't track it.
        LDAPControl[] cont = null;
        if (cons != null) {
          cont = cons.getControls();
        }
        LDAPMessage msg = new LDAPAbandonRequest(msgId, cont);
        // Send abandon message to server
        conn.writeMessage(msg);
      } catch (LDAPException ex) {; // do nothing
      }
      // If not informing user, remove message from agent
      if (informUserEx == null) {
        agent.abandon(msgId, null);
      }
      conn.removeMessage(this);
    }
    // Get rid of all replies queued
    if (informUserEx != null) {
      replies.addElement(new LDAPResponse(informUserEx, conn.getActiveReferral()));
      if (Debug.LDAP_DEBUG) {
        Debug.trace(
            Debug.messages,
            name
                + "Queued exception as LDAPResponse ("
                + replies.size()
                + " in queue):"
                + " following referral="
                + (conn.getActiveReferral() != null)
                + "\n\texception: "
                + informUserEx.getLDAPErrorMessage());
      }
      stopTimer();
      // wake up waiting threads to receive exception
      sleepersAwake();
      // Message will get cleaned up when last response removed from queue
    } else {
      // Wake up any waiting threads, so they can terminate.
      // If informing the user, we wake sleepers after
      // caller queues dummy response with error status
      sleepersAwake();
      cleanup();
    }
    return;
  }