<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.9.1"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>Proton DotNet: Apache.Qpid.Proton.Engine.Sasl.Client.PlainMechanism Class Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="search/searchdata.js"></script>
<script type="text/javascript" src="search/search.js"></script>
<link href="doxygen.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr style="height: 56px;">
  <td id="projectalign" style="padding-left: 0.5em;">
   <div id="projectname">Proton DotNet
   </div>
  </td>
 </tr>
 </tbody>
</table>
</div>
<!-- end header part -->
<!-- Generated by Doxygen 1.9.1 -->
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
var searchBox = new SearchBox("searchBox", "search",false,'Search','.html');
/* @license-end */
</script>
<script type="text/javascript" src="menudata.js"></script>
<script type="text/javascript" src="menu.js"></script>
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
$(function() {
  initMenu('',true,false,'search.php','Search');
  $(document).ready(function() { init_search(); });
});
/* @license-end */</script>
<div id="main-nav"></div>
<!-- window showing the filter options -->
<div id="MSearchSelectWindow"
     onmouseover="return searchBox.OnSearchSelectShow()"
     onmouseout="return searchBox.OnSearchSelectHide()"
     onkeydown="return searchBox.OnSearchSelectKey(event)">
</div>

<!-- iframe showing the search results (closed by default) -->
<div id="MSearchResultsWindow">
<iframe src="javascript:void(0)" frameborder="0" 
        name="MSearchResults" id="MSearchResults">
</iframe>
</div>

<div id="nav-path" class="navpath">
  <ul>
<li class="navelem"><a class="el" href="namespaceApache.html">Apache</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid.html">Qpid</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton.html">Proton</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Engine.html">Engine</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl.html">Sasl</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client.html">Client</a></li><li class="navelem"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1PlainMechanism.html">PlainMechanism</a></li>  </ul>
</div>
</div><!-- top -->
<div class="header">
  <div class="summary">
<a href="#pub-methods">Public Member Functions</a> &#124;
<a href="#pub-static-attribs">Static Public Attributes</a> &#124;
<a href="#properties">Properties</a> &#124;
<a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1PlainMechanism-members.html">List of all members</a>  </div>
  <div class="headertitle">
<div class="title">Apache.Qpid.Proton.Engine.Sasl.Client.PlainMechanism Class Reference</div>  </div>
</div><!--header-->
<div class="contents">

<p><a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation.html">Implementation</a> of the SASL Plain mechanism.  
 <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1PlainMechanism.html#details">More...</a></p>
<div class="dynheader">
Inheritance diagram for Apache.Qpid.Proton.Engine.Sasl.Client.PlainMechanism:</div>
<div class="dyncontent">
 <div class="center">
  <img src="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1PlainMechanism.png" usemap="#Apache.Qpid.Proton.Engine.Sasl.Client.PlainMechanism_map" alt=""/>
  <map id="Apache.Qpid.Proton.Engine.Sasl.Client.PlainMechanism_map" name="Apache.Qpid.Proton.Engine.Sasl.Client.PlainMechanism_map">
<area href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism.html" title="Common base for SASL mechanism types that provides basic service to ease the creation of SASL mechani..." alt="Apache.Qpid.Proton.Engine.Sasl.Client.AbstractMechanism" shape="rect" coords="0,56,350,80"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1IMechanism.html" title="Interface that is implemented by all SASL mechanisms provided in this package." alt="Apache.Qpid.Proton.Engine.Sasl.Client.IMechanism" shape="rect" coords="0,0,350,24"/>
  </map>
</div></div>
<table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
Public Member Functions</h2></td></tr>
<tr class="memitem:a862ab0c52a4b053b33bc4953568c3852"><td class="memItemLeft" align="right" valign="top">override bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1PlainMechanism.html#a862ab0c52a4b053b33bc4953568c3852">IsApplicable</a> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1ISaslCredentialsProvider.html">ISaslCredentialsProvider</a> credentials)</td></tr>
<tr class="memdesc:a862ab0c52a4b053b33bc4953568c3852"><td class="mdescLeft">&#160;</td><td class="mdescRight">Allows the Mechanism to determine if it is a valid choice based on the configured credentials at the time of selection. The sasl processing layer must query each mechanism to determine its applicability and must not attempt to utilize a given mechanism if it reports it cannot be applied using the provided credentials.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1PlainMechanism.html#a862ab0c52a4b053b33bc4953568c3852">More...</a><br /></td></tr>
<tr class="separator:a862ab0c52a4b053b33bc4953568c3852"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa046ba050202f577043c1ae122513133"><td class="memItemLeft" align="right" valign="top">override <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1PlainMechanism.html#aa046ba050202f577043c1ae122513133">GetInitialResponse</a> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1ISaslCredentialsProvider.html">ISaslCredentialsProvider</a> credentials)</td></tr>
<tr class="memdesc:aa046ba050202f577043c1ae122513133"><td class="mdescLeft">&#160;</td><td class="mdescRight">Based on the functionality of the implemented mechanism, formulate the initial response packet that will be sent back to the remote, if no response is required for this mechanism this method may return null.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1PlainMechanism.html#aa046ba050202f577043c1ae122513133">More...</a><br /></td></tr>
<tr class="separator:aa046ba050202f577043c1ae122513133"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism')"><img src="closed.png" alt="-"/>&#160;Public Member Functions inherited from <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism.html">Apache.Qpid.Proton.Engine.Sasl.Client.AbstractMechanism</a></td></tr>
<tr class="memitem:a35b525088befdab621407726f9c0e506 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td class="memItemLeft" align="right" valign="top">virtual <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism.html#a35b525088befdab621407726f9c0e506">GetChallengeResponse</a> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1ISaslCredentialsProvider.html">ISaslCredentialsProvider</a> credentials, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> challenge)</td></tr>
<tr class="memdesc:a35b525088befdab621407726f9c0e506 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td class="mdescLeft">&#160;</td><td class="mdescRight">Based on the functionality of the implemented mechanism, formulate the challenge response packet that will be sent back to the remote. If the mechanism is not expecting a challenge this method my throw an exception.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism.html#a35b525088befdab621407726f9c0e506">More...</a><br /></td></tr>
<tr class="separator:a35b525088befdab621407726f9c0e506 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9f79af7956f0d70a505c7807eb8db982 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td class="memItemLeft" align="right" valign="top">virtual bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism.html#a9f79af7956f0d70a505c7807eb8db982">IsEnabledByDefault</a> ()</td></tr>
<tr class="memdesc:a9f79af7956f0d70a505c7807eb8db982 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td class="mdescLeft">&#160;</td><td class="mdescRight">Allows the mechanism to indicate if it is enabled by default, or only when explicitly enabled through configuring the permitted SASL mechanisms. Any mechanism selection logic should examine this value along with the configured allowed mechanism and decide if this one should be used.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism.html#a9f79af7956f0d70a505c7807eb8db982">More...</a><br /></td></tr>
<tr class="separator:a9f79af7956f0d70a505c7807eb8db982 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6001a6713477491eda12f5462e1c6907 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td class="memItemLeft" align="right" valign="top">virtual void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism.html#a6001a6713477491eda12f5462e1c6907">VerifyCompletion</a> ()</td></tr>
<tr class="memdesc:a6001a6713477491eda12f5462e1c6907 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td class="mdescLeft">&#160;</td><td class="mdescRight">Verifies that the SASL exchange has completed successfully. This is an opportunity for the mechanism to ensure that all mandatory steps have been completed successfully and to cleanup and resources that are held by this Mechanism. When verification fails this method throw a <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1SaslException.html" title="Base exception type for exceptions encountered during SASL authentication.">SaslException</a>.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism.html#a6001a6713477491eda12f5462e1c6907">More...</a><br /></td></tr>
<tr class="separator:a6001a6713477491eda12f5462e1c6907 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8b826c4bc33f5d8b04196d46f3f604e6 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td class="memItemLeft" align="right" valign="top"><a id="a8b826c4bc33f5d8b04196d46f3f604e6"></a>
override string&#160;</td><td class="memItemRight" valign="bottom"><b>ToString</b> ()</td></tr>
<tr class="separator:a8b826c4bc33f5d8b04196d46f3f604e6 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-static-attribs"></a>
Static Public Attributes</h2></td></tr>
<tr class="memitem:aa85f13028e91e89fd1dbdf8848149c3d"><td class="memItemLeft" align="right" valign="top"><a id="aa85f13028e91e89fd1dbdf8848149c3d"></a>
static readonly <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>&#160;</td><td class="memItemRight" valign="bottom"><b>PLAIN</b> = Symbol.Lookup(&quot;PLAIN&quot;)</td></tr>
<tr class="separator:aa85f13028e91e89fd1dbdf8848149c3d"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="properties"></a>
Properties</h2></td></tr>
<tr class="memitem:a4847ff5c91f9e972bc6081f61ec69ffa"><td class="memItemLeft" align="right" valign="top"><a id="a4847ff5c91f9e972bc6081f61ec69ffa"></a>
override <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>&#160;</td><td class="memItemRight" valign="bottom"><b>Name</b><code> [get]</code></td></tr>
<tr class="separator:a4847ff5c91f9e972bc6081f61ec69ffa"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td colspan="2" onclick="javascript:toggleInherit('properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism.html">Apache.Qpid.Proton.Engine.Sasl.Client.AbstractMechanism</a></td></tr>
<tr class="memitem:a1518a96137a976d27381e57faac47f42 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td class="memItemLeft" align="right" valign="top"><a id="a1518a96137a976d27381e57faac47f42"></a>
abstract <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>&#160;</td><td class="memItemRight" valign="bottom"><b>Name</b><code> [get]</code></td></tr>
<tr class="separator:a1518a96137a976d27381e57faac47f42 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1IMechanism"><td colspan="2" onclick="javascript:toggleInherit('properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1IMechanism')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1IMechanism.html">Apache.Qpid.Proton.Engine.Sasl.Client.IMechanism</a></td></tr>
<tr class="memitem:a7f4aa2e38fd799afaae79d51bff4ec5d inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1IMechanism"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1IMechanism.html#a7f4aa2e38fd799afaae79d51bff4ec5d">Name</a><code> [get]</code></td></tr>
<tr class="memdesc:a7f4aa2e38fd799afaae79d51bff4ec5d inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1IMechanism"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the proper name of the SASL mechanism  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1IMechanism.html#a7f4aa2e38fd799afaae79d51bff4ec5d">More...</a><br /></td></tr>
<tr class="separator:a7f4aa2e38fd799afaae79d51bff4ec5d inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1IMechanism"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
Additional Inherited Members</h2></td></tr>
<tr class="inherit_header pro_static_attribs_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td colspan="2" onclick="javascript:toggleInherit('pro_static_attribs_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism')"><img src="closed.png" alt="-"/>&#160;Static Protected Attributes inherited from <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism.html">Apache.Qpid.Proton.Engine.Sasl.Client.AbstractMechanism</a></td></tr>
<tr class="memitem:a990af17bf3eee94d9aa126d70adfce5a inherit pro_static_attribs_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td class="memItemLeft" align="right" valign="top"><a id="a990af17bf3eee94d9aa126d70adfce5a"></a>
static readonly <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><b>EMPTY</b> = ProtonByteBufferAllocator.Instance.Allocate(0, 0)</td></tr>
<tr class="separator:a990af17bf3eee94d9aa126d70adfce5a inherit pro_static_attribs_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table>
<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
<div class="textblock"><p><a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation.html">Implementation</a> of the SASL Plain mechanism. </p>
</div><h2 class="groupheader">Member Function Documentation</h2>
<a id="aa046ba050202f577043c1ae122513133"></a>
<h2 class="memtitle"><span class="permalink"><a href="#aa046ba050202f577043c1ae122513133">&#9670;&nbsp;</a></span>GetInitialResponse()</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">override <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Engine.Sasl.Client.PlainMechanism.GetInitialResponse </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1ISaslCredentialsProvider.html">ISaslCredentialsProvider</a>&#160;</td>
          <td class="paramname"><em>credentialsProvider</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Based on the functionality of the implemented mechanism, formulate the initial response packet that will be sent back to the remote, if no response is required for this mechanism this method may return null. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">credentialsProvider</td><td>The provider of the credentials</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>The initial response encoded into a proton buffer.</dd></dl>

<p>Reimplemented from <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism.html#afaa919377d569c8d2e995d98bc63be63">Apache.Qpid.Proton.Engine.Sasl.Client.AbstractMechanism</a>.</p>

</div>
</div>
<a id="a862ab0c52a4b053b33bc4953568c3852"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a862ab0c52a4b053b33bc4953568c3852">&#9670;&nbsp;</a></span>IsApplicable()</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">override bool Apache.Qpid.Proton.Engine.Sasl.Client.PlainMechanism.IsApplicable </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1ISaslCredentialsProvider.html">ISaslCredentialsProvider</a>&#160;</td>
          <td class="paramname"><em>credentials</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Allows the Mechanism to determine if it is a valid choice based on the configured credentials at the time of selection. The sasl processing layer must query each mechanism to determine its applicability and must not attempt to utilize a given mechanism if it reports it cannot be applied using the provided credentials. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">credentialsProvider</td><td>The provider of the credentials</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true if the mechanism can operate given the provided credentials</dd></dl>

<p>Implements <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Sasl_1_1Client_1_1AbstractMechanism.html#a7551c43011de4767250d398df8b94068">Apache.Qpid.Proton.Engine.Sasl.Client.AbstractMechanism</a>.</p>

</div>
</div>
<hr/>The documentation for this class was generated from the following file:<ul>
<li>src/Proton/Engine/Sasl/Client/PlainMechanism.cs</li>
</ul>
</div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>
Generated by&#160;<a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
</small></address>
</body>
</html>
