private void cleanup() { stopTimer(); // Make sure timer stopped try { acceptReplies = false; conn?.removeMessage(this); // Empty out any accumuluated replies if (replies != null) { while (replies.Count != 0) { var temp_object = replies[0]; replies.RemoveAt(0); object generatedAux = temp_object; } } } catch (Exception ex) { // 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; }
/// <summary> Merges two message queues. It appends the current and /// future contents from another queue to this one. /// /// After the operation, queue2.getMessageIDs() /// returns an empty array, and its outstanding responses /// have been removed and appended to this queue. /// /// </summary> /// <param name="queue2"> The queue that is merged from. Following /// the merge, this queue object will no /// longer receive any data, and calls made /// to its methods will fail with a RuntimeException. /// The queue can be reactivated by using it in an /// Ldap request, after which it will receive responses /// for that request.. /// </param> public virtual void merge(LdapMessageQueue queue2) { LdapResponseQueue q = (LdapResponseQueue) queue2; agent.merge(q.MessageAgent); return ; }
private void cleanup() { stopTimer(); // Make sure timer stopped try { acceptReplies = false; if (conn != null) { conn.removeMessage(this); } // Empty out any accumuluated replies if (replies != null) { while (!(replies.Count == 0)) { object temp_object; temp_object = replies[0]; replies.RemoveAt(0); var generatedAux = temp_object; } } } catch (Exception ex) { LogManager.GetCurrentClassLogger().Warn("Exception swallowed", ex); } _stackTraceCleanup = Environment.StackTrace; // 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; }
/// <summary> Merges two message queues. It appends the current and /// future contents from another queue to this one. /// /// After the operation, queue2.getMessageIDs() /// returns an empty array, and its outstanding responses /// have been removed and appended to this queue. /// /// </summary> /// <param name="queue2"> The queue that is merged from. Following /// the merge, this queue object will no /// longer receive any data, and calls made /// to its methods will fail with a RuntimeException. /// The queue can be reactivated by using it in an /// Ldap request, after which it will receive responses /// for that request.. /// </param> public virtual void merge(LdapMessageQueue queue2) { LdapSearchQueue q = (LdapSearchQueue)queue2; agent.merge(q.MessageAgent); return; }
/// <summary> Send a request to the server. A Message class is created /// for the specified request which causes the message to be sent. /// The request is added to the list of messages being managed by /// this agent. /// /// </summary> /// <param name="conn">the connection that identifies the server. /// /// </param> /// <param name="msg">the LdapMessage to send /// /// </param> /// <param name="timeOut">the interval to wait for the message to complete or /// <code>null</code> if infinite. /// </param> /// <param name="queue">the LdapMessageQueue associated with this request. /// </param> /* package */ internal void sendMessage(Connection conn, LdapMessage msg, int timeOut, LdapMessageQueue queue, BindProperties bindProps) { // creating a messageInfo causes the message to be sent // and a timer to be started if needed. Message message = new Message(msg, timeOut, conn, this, queue, bindProps); messages.Add(message); message.sendMessage(); // Now send message to server }
private BindProperties bindprops; // Bind properties if a bind request internal Message(LdapMessage msg, int mslimit, Connection conn, MessageAgent agent, LdapMessageQueue queue, BindProperties bindprops) { InitBlock(); this.msg = msg; this.conn = conn; this.agent = agent; this.queue = queue; this.mslimit = mslimit; msgId = msg.MessageID; this.bindprops = bindprops; }
private bool waitForReply_Renamed_Field = true; // true if wait for reply #endregion Fields #region Constructors internal Message(LdapMessage msg, int mslimit, Connection conn, MessageAgent agent, LdapMessageQueue queue, BindProperties bindprops) { InitBlock(); this.msg = msg; this.conn = conn; this.agent = agent; this.queue = queue; this.mslimit = mslimit; this.msgId = msg.MessageID; this.bindprops = bindprops; return ; }
private bool _waitForReplyRenamedField = true; // true if wait for reply internal Message(LdapMessage msg, int mslimit, Connection conn, MessageAgent agent, LdapMessageQueue queue, BindProperties bindprops) { _conn = conn ?? throw new ArgumentNullException(nameof(conn)); _stackTraceCreation = Environment.StackTrace; _replies = new MessageVector(5, 5); Request = msg; MessageAgent = agent; _queue = queue; _mslimit = mslimit; MessageId = msg.MessageId; _bindprops = bindprops; }
private BindProperties bindprops; // Bind properties if a bind request internal Message(LdapMessage msg, int mslimit, Connection conn, MessageAgent agent, LdapMessageQueue queue, BindProperties bindprops) { if (conn == null) { throw new ArgumentNullException(nameof(conn)); } _stackTraceCreation = Environment.StackTrace; InitBlock(); this.msg = msg; this.conn = conn; this.agent = agent; this.queue = queue; this.mslimit = mslimit; msgId = msg.MessageID; this.bindprops = bindprops; }
/// <summary> Abandons all outstanding operations managed by the queue. /// /// All operations in progress, which are managed by the specified /// queue, are abandoned. /// /// </summary> /// <param name="queue"> The queue returned from an asynchronous request. /// All outstanding operations managed by the queue /// are abandoned, and the queue is emptied. /// /// </param> /// <param name="cons"> The contraints specific to the operation. /// /// </param> /// <exception> LdapException A general exception which includes an error /// message and an Ldap error code. /// </exception> public virtual void Abandon(LdapMessageQueue queue, LdapConstraints cons) { if (queue != null) { MessageAgent agent; if (queue is LdapSearchQueue) { agent = queue.MessageAgent; } else { agent = queue.MessageAgent; } int[] msgIds = agent.MessageIDs; for (int i = 0; i < msgIds.Length; i++) { agent.Abandon(msgIds[i], cons); } } return ; }
protected void StartEventPolling( LdapMessageQueue queue, LdapConnection conn, int msgid) { // validate the argument values if ( (queue == null) || (conn == null)) { throw new ArgumentException("No parameter can be Null."); } if (null == m_objEventsGenerator) { m_objEventsGenerator = new EventsGenerator(this, queue, conn, msgid); m_objEventsGenerator.SleepTime = sleep_interval; m_objEventsGenerator.StartEventPolling(); } } // end of method StartEventPolling
public EventsGenerator(LdapEventSource objEventSource, LdapMessageQueue queue, LdapConnection conn, int msgid) { m_objLdapEventSource = objEventSource; searchqueue = queue; ldapconnection = conn; messageid = msgid; sleep_time = DEFAULT_SLEEP_TIME; } // end of Constructor
/// <summary> Follow referrals if necessary referral following enabled. /// This function is called only by synchronous requests. /// Search responses come here only if referral following is /// enabled and if we are processing a SearchResultReference /// or a Response with a status of REFERRAL, i.e. we are /// going to follow a referral. /// /// This functions recursively follows a referral until a result /// is returned or until the hop limit is reached. /// /// </summary> /// <param name="queue">The LdapResponseQueue for this request /// /// </param> /// <param name="cons">The constraints that apply to the request /// /// </param> /// <param name="msg">The referral or search reference response message /// /// </param> /// <param name="initialReferrals">The referral array returned from the /// initial request. /// /// </param> /// <param name="hopCount">the number of hops already used while /// following this referral /// /// </param> /// <param name="searchReference">true if the message is a search reference /// /// </param> /// <param name="connectionList">An optional array list used to store /// the LdapConnection objects used in following the referral. /// /// </param> /// <returns> The array list used to store the all LdapConnection objects /// used in following the referral. The list will be empty /// if there were none. /// /// </returns> /// <exception> LdapException A general exception which includes an error /// message and an Ldap error code. /// </exception> /* package */ internal virtual System.Collections.ArrayList chaseReferral(LdapMessageQueue queue, LdapConstraints cons, LdapMessage msg, System.String[] initialReferrals, int hopCount, bool searchReference, System.Collections.ArrayList connectionList) { System.Collections.ArrayList connList = connectionList; LdapConnection rconn = null; // new conn for following referral ReferralInfo rinfo = null; // referral info LdapMessage origMsg; // Get a place to store new connections if (connList == null) { connList = new System.Collections.ArrayList(cons.HopLimit); } // Following referrals or search reference System.String[] refs; // referral list if (initialReferrals != null) { // Search continuation reference from a search request refs = initialReferrals; origMsg = msg.RequestingMessage; } else { // Not a search request LdapResponse resp = (LdapResponse) queue.getResponse(); if (resp.ResultCode != LdapException.REFERRAL) { // Not referral result,throw Exception if nonzero result resp.chkResultCode(); return connList; } // We have a referral response refs = resp.Referrals; origMsg = resp.RequestingMessage; } LdapUrl refUrl; // referral represented as URL try { // increment hop count, check max hops if (hopCount++ > cons.HopLimit) { throw new LdapLocalException("Max hops exceeded", LdapException.REFERRAL_LIMIT_EXCEEDED); } // Get a connection to follow the referral rinfo = getReferralConnection(refs); rconn = rinfo.ReferralConnection; refUrl = rinfo.ReferralUrl; connList.Add(rconn); // rebuild msg into new msg changing msgID,dn,scope,filter LdapMessage newMsg = rebuildRequest(origMsg, refUrl, searchReference); // Send new message on new connection try { MessageAgent agent; if (queue is LdapResponseQueue) { agent = queue.MessageAgent; } else { agent = queue.MessageAgent; } agent.sendMessage(rconn.Connection, newMsg, defSearchCons.TimeLimit, queue, null); } catch (InterThreadException ex) { // Error ending request to referred server LdapReferralException rex = new LdapReferralException(ExceptionMessages.REFERRAL_SEND, LdapException.CONNECT_ERROR, null, ex); rex.setReferrals(initialReferrals); ReferralInfo ref_Renamed = rconn.Connection.ActiveReferral; rex.FailedReferral = ref_Renamed.ReferralUrl.ToString(); throw rex; } if (initialReferrals == null) { // For operation results, when all responses are complete, // the stack unwinds back to the original and returns // to the application. // An exception is thrown for an error connList = chaseReferral(queue, cons, null, null, hopCount, false, connList); } else { // For search, just return to LdapSearchResults object return connList; } } catch (System.Exception ex) { if (ex is LdapReferralException) { throw (LdapReferralException) ex; } else { // Set referral list and failed referral LdapReferralException rex = new LdapReferralException(ExceptionMessages.REFERRAL_ERROR, ex); rex.setReferrals(refs); if (rinfo != null) { rex.FailedReferral = rinfo.ReferralUrl.ToString(); } else { rex.FailedReferral = refs[refs.Length - 1]; } throw rex; } } return connList; }
/// <summary> Check the result code and throw an exception if needed. /// /// If referral following is enabled, checks if we need to /// follow a referral /// /// </summary> /// <param name="queue">- the message queue of the current response /// /// </param> /// <param name="cons">- the constraints that apply to the request /// /// </param> /// <param name="response">- the LdapResponse to check /// </param> private void chkResultCode(LdapMessageQueue queue, LdapConstraints cons, LdapResponse response) { if ((response.ResultCode == LdapException.REFERRAL) && cons.ReferralFollowing) { // Perform referral following and return System.Collections.ArrayList refConn = null; try { chaseReferral(queue, cons, response, response.Referrals, 0, false, null); } finally { releaseReferralConnections(refConn); } } else { // Throws exception for non success result response.chkResultCode(); } return ; }
/// <summary> Sends an Ldap request to a directory server. /// /// The specified the Ldap request is sent to the directory server /// associated with this connection. An Ldap request object is an /// {@link LdapMessage} with the operation type set to one of the request /// types. You can build a request by using the request classes found in this /// package /// /// You should note that, since Ldap requests sent to the server /// using sendRequest are asynchronous, automatic referral following /// does not apply to these requests. /// /// </summary> /// <param name="request">The Ldap request to send to the directory server. /// </param> /// <param name="queue"> The queue for messages returned from a server in /// response to this request. If it is null, a /// queue object is created internally. /// </param> /// <param name="cons"> The constraints that apply to this request /// </param> /// <exception> LdapException A general exception which includes an error /// message and an Ldap error code. /// /// </exception> /// <seealso cref="LdapMessage.Type"> /// </seealso> /// <seealso cref="RfcLdapMessage.isRequest"> /// </seealso> public virtual LdapMessageQueue SendRequest(LdapMessage request, LdapMessageQueue queue, LdapConstraints cons) { if (!request.Request) { throw new System.SystemException("Object is not a request message"); } if (cons == null) { cons = defSearchCons; } // Get the correct queue for a search request MessageAgent agent; LdapMessageQueue myqueue = queue; if (myqueue == null) { agent = new MessageAgent(); if (request.Type == LdapMessage.SEARCH_REQUEST) { myqueue = new LdapSearchQueue(agent); } else { myqueue = new LdapResponseQueue(agent); } } else { if (request.Type == LdapMessage.SEARCH_REQUEST) { agent = queue.MessageAgent; } else { agent = queue.MessageAgent; } } try { agent.sendMessage(conn, request, cons.TimeLimit, myqueue, null); } catch (LdapException lex) { throw lex; } return myqueue; }
private void cleanup() { stopTimer(); // Make sure timer stopped try { acceptReplies = false; if (conn != null) { conn.removeMessage(this); } // Empty out any accumuluated replies if (replies != null) { while (!(replies.Count == 0)) { System.Object temp_object; temp_object = replies[0]; replies.RemoveAt(0); System.Object generatedAux = temp_object; } } } catch (System.Exception ex) { // 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 ; }
/// <summary> Abandons all outstanding operations managed by the queue. /// /// All operations in progress, which are managed by the specified queue, /// are abandoned. /// /// </summary> /// <param name="queue"> The queue returned from an asynchronous request. /// All outstanding operations managed by the queue /// are abandoned, and the queue is emptied. /// /// </param> /// <exception> LdapException A general exception which includes an error /// message and an Ldap error code. /// </exception> public virtual void Abandon(LdapMessageQueue queue) { Abandon(queue, defSearchCons); return ; }
/// <summary> Send a request to the server. A Message class is created /// for the specified request which causes the message to be sent. /// The request is added to the list of messages being managed by /// this agent. /// /// </summary> /// <param name="conn">the connection that identifies the server. /// /// </param> /// <param name="msg">the LdapMessage to send /// /// </param> /// <param name="timeOut">the interval to wait for the message to complete or /// <code>null</code> if infinite. /// </param> /// <param name="queue">the LdapMessageQueue associated with this request. /// </param> /* package */ internal void sendMessage(Connection conn, LdapMessage msg, int timeOut, LdapMessageQueue queue, BindProperties bindProps) { // creating a messageInfo causes the message to be sent // and a timer to be started if needed. Message message = new Message(msg, timeOut, conn, this, queue, bindProps); messages.Add(message); message.sendMessage(); // Now send message to server return ; }
/// <summary> Sends an Ldap request to a directory server. /// /// The specified the Ldap request is sent to the directory server /// associated with this connection using default constraints. An Ldap /// request object is a subclass {@link LdapMessage} with the operation /// type set to one of the request types. You can build a request by using /// the request classes found in this package /// /// You should note that, since Ldap requests sent to the server /// using sendRequest are asynchronous, automatic referral following /// does not apply to these requests. /// /// </summary> /// <param name="request">The Ldap request to send to the directory server. /// </param> /// <param name="queue"> The queue for messages returned from a server in /// response to this request. If it is null, a /// queue object is created internally. /// </param> /// <exception> LdapException A general exception which includes an error /// message and an Ldap error code. /// /// </exception> /// <seealso cref="LdapMessage.Type"> /// </seealso> /// <seealso cref="RfcLdapMessage.isRequest"> /// </seealso> public virtual LdapMessageQueue SendRequest(LdapMessage request, LdapMessageQueue queue) { return SendRequest(request, queue, null); }
/// <summary> Merges two message queues. It appends the current and /// future contents from another queue to this one. /// /// After the operation, queue2.getMessageIDs() /// returns an empty array, and its outstanding responses /// have been removed and appended to this queue. /// /// </summary> /// <param name="queue2"> The queue that is merged from. Following /// the merge, this queue object will no /// longer receive any data, and calls made /// to its methods will fail with a RuntimeException. /// The queue can be reactivated by using it in an /// Ldap request, after which it will receive responses /// for that request.. /// </param> public virtual void merge(LdapMessageQueue queue2) { LdapResponseQueue q = (LdapResponseQueue)queue2; agent.merge(q.MessageAgent); }