<h2>File Contents: /home/planet5/public_html/4xpips.net/wp-content/off-plugins/role-scoper/role-scoper_init.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/4xpips.net/wp-content/off-plugins/role-scoper/role-scoper_init.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php
if( basename(__FILE__) == basename($_SERVER[&#039;SCRIPT_FILENAME&#039;]) )
	die();

require_once( dirname(__FILE__) . &#039;/hardway/cache-persistent.php&#039; );

//if ( ! awp_ver( &#039;3.0&#039; ) )
//	require_once( dirname(__FILE__).&#039;/wp-legacy_rs.php&#039; );

// As of WP 3.0, this is not set until admin_header is loaded, and remains unset for non-admin urls.  To simplify subsequent checks, set it early and universally.
$GLOBALS[&#039;plugin_page_cr&#039;] = ( is_admin() &amp;&amp; isset( $_GET[&#039;page&#039;] ) ) ? $_GET[&#039;page&#039;] : &#039;&#039;;

if ( is_admin() )
	require_once( dirname(__FILE__).&#039;/admin/admin-init_rs.php&#039; );
	
if ( IS_MU_RS )
	require_once( dirname(__FILE__).&#039;/mu-init_rs.php&#039; );

if ( IS_MU_RS || defined(&#039;SCOPER_FORCE_FILE_INCLUSIONS&#039;) ) {
	// workaround to avoid file error on get_home_path() call
	if ( file_exists( ABSPATH . &#039;/wp-admin/includes/file.php&#039; ) )
		include_once( ABSPATH . &#039;/wp-admin/includes/file.php&#039; );	
}

// If an htaccess regeneration is triggered by somebody else, insert our rules (normal non-MU installations).
if ( ! defined( &#039;SCOPER_NO_HTACCESS&#039; ) )
	add_filter( &#039;mod_rewrite_rules&#039;, &#039;scoper_mod_rewrite_rules&#039; );

add_action( &#039;delete_option&#039;, &#039;scoper_maybe_rewrite_inclusions&#039; );
add_action( &#039;delete_transient_rewrite_rules&#039;, &#039;scoper_rewrite_inclusions&#039; );

// some options can be overridden by constant definition
add_filter( &#039;site_options_rs&#039;, &#039;scoper_apply_constants&#039;, 99 );
add_filter( &#039;options_rs&#039;, &#039;scoper_apply_constants&#039;, 99 );

function scoper_log_init_action() {
	define ( &#039;INIT_ACTION_DONE_RS&#039;, true );

	require_once( dirname(__FILE__).&#039;/db-config_rs.php&#039;);
	
	$func = &quot;require(&#039;&quot; . dirname(__FILE__) . &quot;/db-config_rs.php&#039;);&quot;;
	add_action( &#039;switch_blog&#039;, create_function( &#039;&#039;, $func ) );
	
	if ( is_admin() )
		scoper_load_textdomain();

	elseif ( defined(&#039;XMLRPC_REQUEST&#039;) )
		require_once( dirname(__FILE__).&#039;/xmlrpc_rs.php&#039;);
		
	if ( defined( &#039;SSEO_VERSION&#039; ) )
		require_once( dirname(__FILE__).&#039;/eyes-only-helper_rs.php&#039; );
}

function scoper_act_set_current_user() {
	$id = ( ! empty($GLOBALS[&#039;current_user&#039;]) ) ? $GLOBALS[&#039;current_user&#039;]-&gt;ID : 0;

	if ( defined(&#039;MULTISITE&#039;) &amp;&amp; MULTISITE ) {
		scoper_version_check();
	}

	if ( $id || defined( &#039;SCOPER_ANON_METAGROUP&#039; ) ) {
		require_once( dirname(__FILE__).&#039;/scoped-user.php&#039;);
		$GLOBALS[&#039;current_rs_user&#039;] = new WP_Scoped_User($id);
		
		// other properties (blog_roles, assigned_term_roles, term_roles) will be set as populated
		foreach( array( &#039;groups&#039;, &#039;assigned_blog_roles&#039; ) as $var ) {
			$GLOBALS[&#039;current_user&#039;]-&gt;$var = $GLOBALS[&#039;current_rs_user&#039;]-&gt;$var;
		}
	} else {
		require_once( dirname(__FILE__).&#039;/scoped-user_anon.php&#039;);
		$GLOBALS[&#039;current_rs_user&#039;] = new WP_Scoped_User_Anon();
	}

	// since sequence of set_current_user and init actions seems unreliable, make sure our current_user is loaded first
	if ( ! empty( $GLOBALS[&#039;scoper&#039;] ) )
		return;
	elseif ( defined(&#039;INIT_ACTION_DONE_RS&#039;) )
		scoper_init();
	else {
		static $done = false;
		if ( $done ) { return; } else { $done = true; }
		$priority = ( defined( &#039;SCOPER_EARLY_INIT&#039; ) ) ? 3 : 50;
		add_action(&#039;init&#039;, &#039;scoper_init&#039;, $priority);
	}
}

function scoper_init() {
	global $scoper;

	// Work around bug in More Taxonomies (and possibly other plugins) where category taxonomy is overriden without setting it public
	foreach( array( &#039;category&#039;, &#039;post_tag&#039; ) as $taxonomy ) {
		if ( isset( $GLOBALS[&#039;wp_taxonomies&#039;][$taxonomy] ) )
			$GLOBALS[&#039;wp_taxonomies&#039;][$taxonomy]-&gt;public = true;
	}
	
	if ( IS_MU_RS &amp;&amp; agp_is_plugin_network_active( SCOPER_BASENAME ) ) {
		global $scoper_sitewide_options;
		$scoper_sitewide_options = apply_filters( &#039;sitewide_options_rs&#039; , $scoper_sitewide_options );	
	}

	require_once( dirname(__FILE__).&#039;/wp-cap-helper_cr.php&#039; );
	WP_Cap_Helper_CR::establish_status_caps();
	WP_Cap_Helper_CR::force_distinct_post_caps();
	WP_Cap_Helper_CR::force_distinct_taxonomy_caps();
	
	if ( is_admin() ) {
		require_once( dirname(__FILE__).&#039;/admin/admin-init_rs.php&#039; );	// TODO: why is the require statement up top not sufficient for NGG 1.7.2 uploader?
		scoper_admin_init();	
	}

	//log_mem_usage_rs( &#039;scoper_admin_init done&#039; );
		
	require_once( dirname(__FILE__).&#039;/scoped-user.php&#039;);
	require_once( dirname(__FILE__).&#039;/role-scoper_main.php&#039;);
	
	//log_mem_usage_rs( &#039;require role-scoper_main&#039; );
	
	if ( empty($scoper) ) {		// set_current_user may have already triggered scoper creation and role_cap load
		$scoper = new Scoper();
		
		//log_mem_usage_rs( &#039;new Scoper done&#039; );
		$scoper-&gt;init();
	}

	// ensure that content administrators (as defined by SCOPER_CONTENT_ADMIN_CAP) have all caps for custom types by default
	if ( is_content_administrator_rs() ) {
		global $current_rs_user;

		if ( ! empty($current_rs_user) ) { // user object not set when scoper_init() is manually invoked to support htaccess rule generation on plugin activation
			foreach ( get_post_types( array(&#039;public&#039; =&gt; true, &#039;_builtin&#039; =&gt; false) ) as $name )
				$current_rs_user-&gt;assigned_blog_roles[ANY_CONTENT_DATE_RS][&quot;rs_{$name}_editor&quot;] = true;
			
			$taxonomies = get_taxonomies( array(&#039;public&#039; =&gt; true, &#039;_builtin&#039; =&gt; false) );
			$taxonomies []= &#039;nav_menu&#039;;
			foreach ( $taxonomies as $name )
				$current_rs_user-&gt;assigned_blog_roles[ANY_CONTENT_DATE_RS][&quot;rs_{$name}_manager&quot;] = true;
			
			$current_rs_user-&gt;merge_scoped_blogcaps();
			$GLOBALS[&#039;current_user&#039;]-&gt;allcaps = array_merge( $GLOBALS[&#039;current_user&#039;]-&gt;allcaps, $current_rs_user-&gt;allcaps );
			$GLOBALS[&#039;current_user&#039;]-&gt;assigned_blog_roles = $current_rs_user-&gt;assigned_blog_roles;
		}
	}
	
	if ( ! empty($_GET[&#039;action&#039;]) &amp;&amp; ( &#039;expire_file_rules&#039; == $_GET[&#039;action&#039;] ) ) {
		require_once( dirname(__FILE__).&#039;/attachment-helper_rs.php&#039; );
		scoper_requested_file_rule_expire();
	}

	//log_mem_usage_rs( &#039;scoper-&gt;init() done&#039; );
}

function rs_get_user( $user_id, $name = &#039;&#039;, $args = array() ) {
	if ( ! class_exists( &#039;WP_Scoped_User&#039; ) )
		require_once( dirname(__FILE__).&#039;/scoped-user.php&#039;);
	
	return new WP_Scoped_User( $user_id, $name, $args );
}

function scoper_load_textdomain() {
	if ( defined( &#039;SCOPER_TEXTDOMAIN_LOADED&#039; ) )
		return;

	load_plugin_textdomain( &#039;scoper&#039;, false, SCOPER_FOLDER . &#039;/languages&#039; );

	define(&#039;SCOPER_TEXTDOMAIN_LOADED&#039;, true);
}

function scoper_get_init_options() {
	define ( &#039;SCOPER_CUSTOM_USER_BLOGCAPS&#039;, scoper_get_option(&#039;custom_user_blogcaps&#039;) );		// TODO: eliminate this?
	
	$define_groups = scoper_get_option(&#039;define_usergroups&#039;);
	define ( &#039;DEFINE_GROUPS_RS&#039;, $define_groups );
	define ( &#039;GROUP_ROLES_RS&#039;, $define_groups &amp;&amp; scoper_get_option(&#039;enable_group_roles&#039;) );
	
	define ( &#039;USER_ROLES_RS&#039;, scoper_get_option(&#039;enable_user_roles&#039;) );
	
	if ( ! defined(&#039;DISABLE_PERSISTENT_CACHE&#039;) &amp;&amp; ! scoper_get_option(&#039;persistent_cache&#039;) )
		define ( &#039;DISABLE_PERSISTENT_CACHE&#039;, true );
	
	if ( IS_MU_RS ) {
		scoper_establish_group_scope();
	}
	
	// Persistent cache has been disabled due to a vulnerability; delete cache files
	$dir = (defined(&#039;CACHE_PATH&#039;)) ? CACHE_PATH . &#039;rs&#039; : WP_CONTENT_DIR . DIRECTORY_SEPARATOR . &#039;cache&#039; . DIRECTORY_SEPARATOR . &#039;rs&#039;;
	if ( file_exists( $dir ) ) {
		require_once( dirname(__FILE__) . &#039;/hardway/cache-purge.php&#039; );
		scoper_purge_cache_files( $dir );
	}
}

function scoper_refresh_options() {
	if ( IS_MU_RS &amp;&amp; agp_is_plugin_network_active( SCOPER_BASENAME ) ) {
		scoper_retrieve_options(true);
		scoper_refresh_options_sitewide();
	}
		
	scoper_retrieve_options(false);
	
	scoper_refresh_default_options();
}

function scoper_set_conditional_defaults() {
	// if the WP installation has 100 or more users at initial Role Scoper installation, default to CSV input of username for role assignment	
	global $wpdb;
	$num_users = $wpdb-&gt;get_var( &quot;SELECT COUNT(ID) FROM $wpdb-&gt;users&quot; );
	if ( $num_users &gt; 99 )
		update_option( &#039;scoper_user_role_assignment_csv&#039;, 1 );
}

function scoper_refresh_default_options() {
	global $scoper_default_options;

	require_once( dirname(__FILE__).&#039;/defaults_rs.php&#039;);
	$scoper_default_options = apply_filters( &#039;default_options_rs&#039;, scoper_default_options() );
	
	if ( IS_MU_RS &amp;&amp; agp_is_plugin_network_active( SCOPER_BASENAME ) )
		scoper_apply_custom_default_options( &#039;scoper_default_options&#039; );
}

function scoper_refresh_default_otype_options() {
	global $scoper_default_otype_options;
	
	require_once( dirname(__FILE__).&#039;/defaults_rs.php&#039;);
	$scoper_default_otype_options = apply_filters( &#039;default_otype_options_rs&#039;, scoper_default_otype_options() );
	
	// compat workaround for old versions of Role Scoping for NGG which use old otype option key structure
	if ( isset( $scoper_default_otype_options[&#039;use_term_roles&#039;][&#039;ngg_gallery:ngg_gallery&#039;] ) &amp;&amp; ( ! is_array($scoper_default_otype_options[&#039;use_term_roles&#039;][&#039;ngg_gallery:ngg_gallery&#039;]) ) )
		$scoper_default_otype_options[&#039;use_term_roles&#039;][&#039;ngg_gallery:ngg_gallery&#039;] = array( &#039;ngg_album&#039; =&gt; 1 );
		
	if ( IS_MU_RS &amp;&amp; agp_is_plugin_network_active( SCOPER_BASENAME ) )
		scoper_apply_custom_default_options( &#039;scoper_default_otype_options&#039; );
}

function scoper_get_default_otype_options() {
	if ( did_action( &#039;scoper_init&#039;) ) {
		global $scoper_default_otype_options;
		
		if ( ! isset( $scoper_default_otype_options ) )
			scoper_refresh_default_otype_options();
			
		return $scoper_default_otype_options;
	} else
		return scoper_default_otype_options();	
}

function scoper_delete_option( $option_basename, $sitewide = -1 ) {
	// allow explicit selection of sitewide / non-sitewide scope for better performance and update security
	if ( -1 === $sitewide ) {
		global $scoper_options_sitewide;
		$sitewide = isset( $scoper_options_sitewide ) &amp;&amp; ! empty( $scoper_options_sitewide[$option_basename] );
	}

	if ( $sitewide ) {
		global $wpdb;
		scoper_query( &quot;DELETE FROM {$wpdb-&gt;sitemeta} WHERE site_id = &#039;$wpdb-&gt;siteid&#039; AND meta_key = &#039;scoper_$option_basename&#039;&quot; );
	} else 
		delete_option( &quot;scoper_$option_basename&quot; );
}

function scoper_update_option( $option_basename, $option_val, $sitewide = -1 ) {
	// allow explicit selection of sitewide / non-sitewide scope for better performance and update security
	if ( -1 === $sitewide ) {
		global $scoper_options_sitewide;
		$sitewide = isset( $scoper_options_sitewide ) &amp;&amp; ! empty( $scoper_options_sitewide[$option_basename] );
	}
	
	if ( $sitewide ) {
		global $scoper_site_options;
		$scoper_site_options[$option_basename] = $option_val;
		
		//d_echo(&quot;&lt;br /&gt;&lt;br /&gt;sitewide: $option_basename, value : &quot; . maybe_serialize($option_val) );
		update_site_option( &quot;scoper_$option_basename&quot;, $option_val );
	} else {
		//d_echo(&quot;&lt;br /&gt;blogwide: $option_basename&quot; );
		global $scoper_blog_options;
		$scoper_blog_options[$option_basename] = $option_val;

		update_option( &quot;scoper_$option_basename&quot;, $option_val );
	}
}

function scoper_apply_constants($stored_options) {
	// If file filtering option is on but the DISABLE constant has been set, turn the option off and regenerate .htaccess
	if ( defined( &#039;DISABLE_ATTACHMENT_FILTERING&#039; ) &amp;&amp; DISABLE_ATTACHMENT_FILTERING ) {
		if ( ! empty( $stored_options[&#039;scoper_file_filtering&#039;] ) ) {
			// in this case, we need to both convert the option value to constant value AND trigger .htaccess regeneration
			$stored_options[&#039;file_filtering&#039;] = 0;
			update_option( &#039;scoper_file_filtering&#039;, 0 );
			scoper_flush_site_rules();
			scoper_expire_file_rules();	
		}
	}

	return $stored_options; 
}

function scoper_retrieve_options( $sitewide = false ) {
	global $wpdb;
	
	if ( $sitewide ) {
		global $scoper_site_options;
		
		$scoper_site_options = array();

		if ( $results = scoper_get_results( &quot;SELECT meta_key, meta_value FROM $wpdb-&gt;sitemeta WHERE site_id = &#039;$wpdb-&gt;siteid&#039; AND meta_key LIKE &#039;scoper_%&#039;&quot; ) )
			foreach ( $results as $row )
				$scoper_site_options[$row-&gt;meta_key] = $row-&gt;meta_value;
				
		$scoper_site_options = apply_filters( &#039;site_options_rs&#039;, $scoper_site_options );
		return $scoper_site_options;

	} else {
		global $scoper_blog_options;
		
		$scoper_blog_options = array();
		
		if ( $results = scoper_get_results(&quot;SELECT option_name, option_value FROM $wpdb-&gt;options WHERE option_name LIKE &#039;scoper_%&#039;&quot;) )
			foreach ( $results as $row )
				$scoper_blog_options[$row-&gt;option_name] = $row-&gt;option_value;
				
		$scoper_blog_options = apply_filters( &#039;options_rs&#039;, $scoper_blog_options );
		return $scoper_blog_options;
	}
}


function scoper_get_site_option( $option_basename ) {
	return scoper_get_option( $option_basename, true );
}

function scoper_get_option($option_basename, $sitewide = -1, $get_default = false) {
	global $scoper_default_options;
	
	//if ( empty( $scoper_default_options ) &amp;&amp; did_action( &#039;scoper_init&#039; ) )	// Make sure other plugins have had a chance to apply any filters to default options
	if ( empty( $scoper_default_options ) )
		scoper_refresh_default_options();

	if ( ! $get_default ) {
		// allow explicit selection of sitewide / non-sitewide scope for better performance and update security
		if ( -1 === $sitewide ) {
			global $scoper_options_sitewide;
			$sitewide = isset( $scoper_options_sitewide ) &amp;&amp; ! empty( $scoper_options_sitewide[$option_basename] );
		}
	
		//dump($scoper_options_sitewide);
		
		if ( $sitewide ) {
			// this option is set site-wide
			global $scoper_site_options;
			
			if ( ! isset($scoper_site_options) || is_null($scoper_site_options) )
				$scoper_site_options = scoper_retrieve_options( true );	
				
			if ( isset($scoper_site_options[&quot;scoper_{$option_basename}&quot;]) )
				$optval = $scoper_site_options[&quot;scoper_{$option_basename}&quot;];
			
		} else {
			//dump($option_basename);
			global $scoper_blog_options;
			
			if ( ! isset($scoper_blog_options) || is_null($scoper_blog_options) )
				$scoper_blog_options = scoper_retrieve_options( false );	
				
			if ( isset($scoper_blog_options[&quot;scoper_$option_basename&quot;]) )
				$optval = $scoper_blog_options[&quot;scoper_$option_basename&quot;];
		}
	}
	
	//dump($get_default);
	//dump($scoper_blog_options);

	if ( ( &#039;mu_sitewide_groups&#039; == $option_basename ) &amp;&amp; ! agp_is_plugin_network_active( SCOPER_BASENAME ) ) {
		return false;
	}
	
	if ( ! isset( $optval ) ) {
		if ( ! empty($scoper_default_options) &amp;&amp; ! empty( $scoper_default_options[$option_basename] ) )
			$optval = $scoper_default_options[$option_basename];
			
		if ( ! isset($optval) ) {
			global $scoper_default_otype_options;
			if ( isset( $scoper_default_otype_options[$option_basename] ) )
				return $scoper_default_otype_options[$option_basename];
			
			/*
			else {
				static $hardcode_option_defaults;
			
				if ( empty($hardcode_option_defaults) ) {
					require_once( dirname(__FILE__).&#039;/defaults_rs.php&#039;);
					$hardcode_option_defaults = scoper_default_options();
				}
					
				if ( isset($hardcode_option_defaults[$option_basename]) )
					$optval = $hardcode_option_defaults[$option_basename];	
				else {
					static $hardcode_otype_option_defaults;
					
					if ( empty($hardcode_otype_option_defaults) )
						$hardcode_otype_option_defaults = scoper_default_otype_options();
					
					if ( isset($hardcode_otype_option_defaults[$option_basename]) )
						$optval = $hardcode_otype_option_defaults[$option_basename];	
				}	
			}
			*/
		}
	}

	if ( isset($optval) )
		$optval = maybe_unserialize($optval);
	else
		$optval = &#039;&#039;;
		
	// merge defaults into stored option array
	//if ( ! empty( $GLOBALS[&#039;scoper_option_arrays&#039;][$option_basename] ) ) {
		
	if ( &#039;use_post_types&#039; == $option_basename ) {
		static $default_post_types;
		if ( empty($default_post_types) || ! did_action(&#039;init&#039;) ) {
			$default_post_types = array();
			
			foreach ( array_diff( get_post_types( array( &#039;public&#039; =&gt; true ) ), array( &#039;attachment&#039; ) ) as $type )
				$default_post_types[$type] = 1;
		}
		
		$optval = array_merge( $default_post_types, (array) $optval );

	} elseif ( &#039;use_taxonomies&#039; == $option_basename ) {	
		static $default_taxonomies;
		if ( empty($default_taxonomies) || ! did_action(&#039;init&#039;) ) {
			$default_taxonomies = array();
			
			$taxonomies = get_taxonomies( array( &#039;public&#039; =&gt; true ) );
			$taxonomies[] = &#039;nav_menu&#039;;

			foreach ( $taxonomies as $taxonomy )
				$default_taxonomies[$taxonomy] = ( isset( $GLOBALS[&#039;rs_default_disable_taxonomies&#039;][$taxonomy] ) ) ? 0 : 1;
		}

		$optval = array_diff_key( array_merge( $default_taxonomies, (array) $optval ), $GLOBALS[&#039;rs_forbidden_taxonomies&#039;] );  // remove forbidden taxonomies, even if previously stored
	} elseif ( &#039;use_term_roles&#039; == $option_basename ) {
		if ( $optval ) {
			foreach( array_keys($optval) as $key ) {
				$optval[$key] = array_diff_key( $optval[$key], $GLOBALS[&#039;rs_forbidden_taxonomies&#039;] ); // remove forbidden taxonomies, even if previously stored
			}
		}
	}
	
	return $optval;
}

function scoper_get_otype_option( $option_main_key, $src_name, $object_type = &#039;&#039;, $access_name = &#039;&#039;)  {
	static $otype_options;

	// make sure we indicate object roles disabled if object type usage is completely disabled
	if ( &#039;use_object_roles&#039; == $option_main_key ) {
		if ( ( &#039;post&#039; == $src_name ) &amp;&amp; $object_type ) {
			$use_object_types = scoper_get_option( &#039;use_post_types&#039; );
			if ( ( ! empty($use_object_types) ) &amp;&amp; empty( $use_object_types[$object_type] ) )	// since default is to enable all object types, don&#039;t interfere if no use_object_types option is stored
				return false;
		}
	}
	
	$key = &quot;$option_main_key,$src_name,$object_type,$access_name&quot;;

	if ( empty($otype_options) )
		$otype_options = array();
	elseif ( isset($otype_options[$key]) )
		return $otype_options[$key];

	$stored_option = scoper_get_option($option_main_key);

	$default_otype_options = scoper_get_default_otype_options();
	
	// RS stores all portions of the otype option array together, but blending is needed because RS Extensions or other plugins can filter the default otype options array for specific taxonomies / object types
	$optval = awp_blend_option_array( &#039;scoper_&#039;, $option_main_key, $default_otype_options, 1, $stored_option );
	
	// note: access_name-specific entries are not valid for most otype options (but possibly for teaser text front vs. rss)
	if ( isset ( $optval[$src_name] ) )
		$retval = $optval[$src_name];
	
	if ( $object_type &amp;&amp; isset( $optval[&quot;$src_name:$object_type&quot;] ) )
		$retval = $optval[&quot;$src_name:$object_type&quot;];
	
	if ( $object_type &amp;&amp; $access_name &amp;&amp; isset( $optval[&quot;$src_name:$object_type:$access_name&quot;] ) )
		$retval = $optval[&quot;$src_name:$object_type:$access_name&quot;];
	

	// if no match was found for a source request, accept any non-empty otype match
	if ( ! $object_type &amp;&amp; ! isset($retval) )
		foreach ( $optval as $src_otype =&gt; $val )
			if ( $val &amp;&amp; ( 0 === strpos( $src_otype, &quot;$src_name:&quot; ) ) )
				$retval = $val;

	if ( ! isset($retval) )
		$retval = array();
		
	$otype_options[$key] = $retval;
	
	return $retval;
}

function is_taxonomy_used_rs( $taxonomy ) {
	global $scoper_default_otype_options;

	$stored_option = (array) scoper_get_option( &#039;use_term_roles&#039; );
	foreach( array_merge( array_keys($scoper_default_otype_options[&#039;use_term_roles&#039;]), array_keys($stored_option) ) as $key ) {
		$term_roles[$key] = ( isset($scoper_default_otype_options[&#039;use_term_roles&#039;][$key]) ) ? $scoper_default_otype_options[&#039;use_term_roles&#039;][$key] : array();
		
		if ( isset( $stored_option[$key] ) )
			$term_roles[$key] =	array_merge( $term_roles[$key], $stored_option[$key] );
	}

	foreach ( $term_roles as $taxonomies )  // keyed by src_otype
		if ( ! empty( $taxonomies[$taxonomy] ) )
			return true;
}

function scoper_maybe_rewrite_inclusions ( $option_name = &#039;&#039; ) {
	if ( $option_name == &#039;rewrite_rules&#039; )
		scoper_rewrite_inclusions();
}

function scoper_rewrite_inclusions ( $option_name = &#039;&#039; ) {
	// force inclusion of required files in case flush_rules() is called from outside wp-admin, to prevent error when calling get_home_path() function
	if ( file_exists( ABSPATH . &#039;/wp-admin/includes/misc.php&#039; ) )
		include_once( ABSPATH . &#039;/wp-admin/includes/misc.php&#039; );
	
	if ( file_exists( ABSPATH . &#039;/wp-admin/includes/file.php&#039; ) )
		include_once( ABSPATH . &#039;/wp-admin/includes/file.php&#039; );	
}

// htaccess directive intercepts direct access to uploaded files, converts to WP call with custom args to be caught by subsequent parse_query filter
// parse_query filter will return content only if user can read a containing post/page
function scoper_mod_rewrite_rules ( $rules ) {
	if ( defined( &#039;SCOPER_NO_HTACCESS&#039; ) )
		return $rules;
	
	$file_filtering = scoper_get_option( &#039;file_filtering&#039; );

	global $scoper;
	if ( ! isset($scoper) || is_null($scoper) )
		scoper_init();
	
	require_once( dirname(__FILE__).&#039;/rewrite-rules_rs.php&#039; );

	if ( IS_MU_RS ) {
		if ( $file_filtering ) {
			require_once( dirname(__FILE__).&#039;/rewrite-mu_rs.php&#039; );
			$rules = ScoperRewriteMU::insert_site_rules( $rules );
		}
	} else {
		if ( ! strpos( $rules, &#039;BEGIN Role Scoper&#039; ) ) {
			$rs_rules = ScoperRewrite::build_site_rules();
			$rules .= $rs_rules;
		}
	}

	return $rules;
}

function scoper_flush_site_rules() {
	require_once( dirname(__FILE__).&#039;/rewrite-rules_rs.php&#039; );
	ScoperRewrite::update_site_rules( true );
}

function scoper_clear_site_rules() {
	require_once( dirname(__FILE__).&#039;/rewrite-rules_rs.php&#039; );
	remove_filter(&#039;mod_rewrite_rules&#039;, &#039;scoper_mod_rewrite_rules&#039;);
	ScoperRewrite::update_site_rules( false );
}

function scoper_flush_file_rules() {
	require_once( dirname(__FILE__).&#039;/rewrite-rules_rs.php&#039; );
	ScoperRewrite::update_blog_file_rules();
}


function scoper_clear_all_file_rules() {
	if ( IS_MU_RS ) {
		require_once( dirname(__FILE__).&#039;/rewrite-mu_rs.php&#039; );
		ScoperRewriteMU::clear_all_file_rules();
	} else {
		require_once( dirname(__FILE__).&#039;/rewrite-rules_rs.php&#039; );
		ScoperRewrite::update_blog_file_rules( false );
	} 
}


// forces content rules to be regenerated in every MU blog at next access
function scoper_expire_file_rules() {
	if ( IS_MU_RS )
		scoper_update_option( &#039;file_htaccess_min_date&#039;, agp_time_gmt(), true );
	else {
		if ( did_action( &#039;scoper_init&#039; ) )
			scoper_flush_file_rules();  // for non-MU, just regenerate the file rules (for uploads folder) now
		else
			add_action( &#039;scoper_init&#039;, &#039;scoper_flush_file_rules&#039; );
	}
}


function scoper_version_check() {
	$ver_change = false;

	$ver = get_option(&#039;scoper_version&#039;);
	
	if ( empty($ver[&#039;db_version&#039;]) || version_compare( SCOPER_DB_VERSION, $ver[&#039;db_version&#039;], &#039;!=&#039;) ) {
		$ver_change = true;
		
		require_once( dirname(__FILE__).&#039;/db-setup_rs.php&#039;);
		scoper_db_setup($ver[&#039;db_version&#039;]);
	}

	// These maintenance operations only apply when a previous version of RS was installed 
	if ( ! empty($ver[&#039;version&#039;]) ) {
		
		if ( version_compare( SCOPER_VERSION, $ver[&#039;version&#039;], &#039;!=&#039;) ) {
			$ver_change = true;
			
			require_once( dirname(__FILE__).&#039;/admin/update_rs.php&#039;);
			scoper_version_updated( $ver[&#039;version&#039;] );

			scoper_check_revision_settings();
		}
		
	} else {
		// first-time install (or previous install was totally wiped)
		require_once( dirname(__FILE__).&#039;/admin/update_rs.php&#039;);
		scoper_set_default_rs_roledefs();
	}

	if ( $ver_change ) {
		$ver = array(
			&#039;version&#039; =&gt; SCOPER_VERSION, 
			&#039;db_version&#039; =&gt; SCOPER_DB_VERSION
		);
		
		update_option( &#039;scoper_version&#039;, $ver );
	}
}

function scoper_get_role_handle($role_name, $role_type) {
	return $role_type . &#039;_&#039; . str_replace(&#039; &#039;, &#039;_&#039;, $role_name);
}

function scoper_role_names_to_handles($role_names, $role_type, $fill_keys = false) {
	$role_names = (array) $role_names;	

	$role_handles = array();
	foreach ( $role_names as $role_name )
		if ( $fill_keys )
			$role_handles[ $role_type . &#039;_&#039; . str_replace(&#039; &#039;, &#039;_&#039;, $role_name) ] = 1;
		else
			$role_handles[]= $role_type . &#039;_&#039; . str_replace(&#039; &#039;, &#039;_&#039;, $role_name);
			
	return $role_handles;
}

function scoper_explode_role_handle($role_handle) {
	global $scoper_role_types;
	$arr = (object) array();
	
	foreach ( $scoper_role_types as $role_type ) {
		if ( 0 === strpos($role_handle, $role_type . &#039;_&#039;) ) {
			$arr-&gt;role_type = $role_type;
			$arr-&gt;role_name = substr($role_handle, strlen($role_type) + 1);
			break;
		}
	}
	
	return $arr;
}

function scoper_role_handles_to_names($role_handles) {
	global $scoper_role_types;

	$role_names = array();
	foreach ( $role_handles as $role_handle ) {
		foreach ( $scoper_role_types as $role_type )
			$role_handle = str_replace( $role_type . &#039;_&#039;, &#039;&#039;, $role_handle);
			
		$role_names[] = $role_handle;
	}
	
	return $role_names;
}

function rs_notice($message) {
	if ( defined( &#039;RS_DEBUG&#039; ) ) {
		require_once( dirname(__FILE__).&#039;/error_rs.php&#039; );
		awp_notice( $message, &#039;Role Scoper&#039; );
	}
}


// db wrapper methods allow us to easily avoid re-filtering our own query
function scoper_db_method($method_name, $query) {
	global $wpdb;
	//static $buffer;
	
	if ( is_admin() ) { // Low-level query filtering is necessary due to WP API limitations pertaining to admin GUI.
						// But make sure we don&#039;t chew our own cud (currently not an issue for front end)
		global $scoper_status;
	
		if ( empty($scoper_status) )
			$scoper_status = (object) array();
			
		/*
		$use_buffer = (&#039;query&#039; != $method_name ) &amp;&amp; empty($_POST);
		
		if ( $use_buffer ) {
			$key = md5($query);
			if ( isset($buffer[$key]) )
				return $buffer[$key];
		}
		*/

		$scoper_status-&gt;querying_db = true;
		$results = call_user_func( array(&amp;$wpdb, $method_name), $query );
		$scoper_status-&gt;querying_db = false;
		
		//if ( $use_buffer )
		//	$buffer[$key] = $results;
		
		return $results;
	} else
		return call_user_func( array(&amp;$wpdb, $method_name), $query );
}

function scoper_get_results($query) {
	return scoper_db_method(&#039;get_results&#039;, $query);
}

function scoper_get_row($query) {
	return scoper_db_method(&#039;get_row&#039;, $query);
}

function scoper_get_col($query) {
	return scoper_db_method(&#039;get_col&#039;, $query);
}

function scoper_get_var($query) {
	return scoper_db_method(&#039;get_var&#039;, $query);
}

function scoper_query($query) {
	return scoper_db_method(&#039;query&#039;, $query);
}

function scoper_querying_db() {
	if ( isset($GLOBALS[&#039;scoper_status&#039;]) )
		return ! empty($GLOBALS[&#039;scoper_status&#039;]-&gt;querying_db);
}

function scoper_any_role_limits() {
	global $wpdb;
	
	$any_limits = (object) array( &#039;date_limited&#039; =&gt; false, &#039;start_date_gmt&#039; =&gt; false, &#039;end_date_gmt&#039; =&gt; false, &#039;content_date_limited&#039; =&gt; false, &#039;content_min_date_gmt&#039; =&gt; false, &#039;content_max_date_gmt&#039; =&gt; false );

	if ( scoper_get_var( &quot;SELECT assignment_id FROM $wpdb-&gt;user2role2object_rs WHERE date_limited &gt; 0 LIMIT 1&quot; ) ) {
		$any_limits-&gt;date_limited = true;
		
		if ( scoper_get_var( &quot;SELECT assignment_id FROM $wpdb-&gt;user2role2object_rs WHERE start_date_gmt &gt; 0 LIMIT 1&quot; ) )
			$any_limits-&gt;start_date_gmt = true;
			
		if ( scoper_get_var( &quot;SELECT assignment_id FROM $wpdb-&gt;user2role2object_rs WHERE end_date_gmt != &#039;&quot; . SCOPER_MAX_DATE_STRING . &quot;&#039; LIMIT 1&quot; ) )
			$any_limits-&gt;end_date_gmt = true;
	}
	
	if ( scoper_get_option( &#039;role_content_date_limits&#039; ) &amp;&amp; scoper_get_var( &quot;SELECT assignment_id FROM $wpdb-&gt;user2role2object_rs WHERE content_date_limited &gt; 0 LIMIT 1&quot; ) ) {
		$any_limits-&gt;content_date_limited = true;
		
		if ( scoper_get_var( &quot;SELECT assignment_id FROM $wpdb-&gt;user2role2object_rs WHERE content_min_date_gmt &gt; 0 LIMIT 1&quot; ) )
			$any_limits-&gt;content_min_date_gmt = true;
			
		if ( scoper_get_var( &quot;SELECT assignment_id FROM $wpdb-&gt;user2role2object_rs WHERE content_max_date_gmt != &#039;&quot; . SCOPER_MAX_DATE_STRING . &quot;&#039; LIMIT 1&quot; ) )
			$any_limits-&gt;content_max_date_gmt = true;
	}
	
	return $any_limits;
}

function scoper_get_duration_clause( $content_date_comparison = &#039;&#039;, $table_prefix = &#039;uro&#039;, $enforce_duration_limits = true ) {
	static $any_role_limits;
	
	$clause = &#039;&#039;;
	
	if ( $enforce_duration_limits &amp;&amp; scoper_get_option( &#039;role_duration_limits&#039; ) ) {
		if ( ! isset($any_role_limits) )
			$any_role_limits = scoper_any_role_limits();
		
		if ( $any_role_limits-&gt;date_limited ) {
			$current_time = current_time( &#039;mysql&#039;, 1 );
			
			$subclauses = array();
			
			if ( $any_role_limits-&gt;start_date_gmt )
				$subclauses []= &quot;$table_prefix.start_date_gmt &lt;= &#039;$current_time&#039;&quot;;
			
			if ( $any_role_limits-&gt;end_date_gmt )
				$subclauses []= &quot;$table_prefix.end_date_gmt &gt;= &#039;$current_time&#039;&quot;;
			
			$role_duration_clause = implode( &quot; AND &quot;, $subclauses );

			$clause = &quot; AND ( $table_prefix.date_limited = &#039;0&#039; OR ( $role_duration_clause ) ) &quot;;
		}
	}

	if ( $content_date_comparison &amp;&amp; scoper_get_option( &#039;role_content_date_limits&#039; ) ) {
		
		if ( ! isset($any_role_limits) )
			$any_role_limits = scoper_any_role_limits();
		
		if ( $any_role_limits-&gt;content_date_limited ) {
			$current_time = current_time( &#039;mysql&#039;, 1 );
			
			$subclauses = array();
			
			if ( $any_role_limits-&gt;content_min_date_gmt )
				$subclauses []= &quot;$content_date_comparison &gt;= $table_prefix.content_min_date_gmt&quot;;
			
			if ( $any_role_limits-&gt;content_max_date_gmt )
				$subclauses []= &quot;$content_date_comparison &lt;= $table_prefix.content_max_date_gmt&quot;;
			
			$content_date_clause = implode( &quot; AND &quot;, $subclauses );

			$clause .= &quot; AND ( $table_prefix.content_date_limited = &#039;0&#039; OR ( $content_date_clause ) ) &quot;;
		}
	}
	
	return $clause;
}

function scoper_get_property_array( &amp;$arr, $id_prop, $buffer_prop ) {
	if ( ! is_array($arr) )
		return;

	$buffer = array();
		
	foreach ( array_keys($arr) as $key )
		$buffer[ $arr[$key]-&gt;$id_prop ] = ( isset($arr[$key]-&gt;$buffer_prop) ) ? $arr[$key]-&gt;$buffer_prop : &#039;&#039;;

	return $buffer;
}

function scoper_restore_property_array( &amp;$target_arr, $buffer_arr, $id_prop, $buffer_prop ) {
	if ( ! is_array($target_arr) || ! is_array($buffer_arr) )
		return;
		
	foreach ( array_keys($target_arr) as $key )
		if ( isset( $buffer_arr[ $target_arr[$key]-&gt;$id_prop ] ) )
			$target_arr[$key]-&gt;$buffer_prop = $buffer_arr[ $target_arr[$key]-&gt;$id_prop ];
}

function scoper_get_taxonomy_usage( $src_name, $object_types = &#039;&#039; ) {
	$taxonomies = array();
	$object_types = (array) $object_types;

	foreach( $object_types as $object_type ) {
		if ( taxonomy_exists( $object_type ) )
			$use_taxonomies = array( $object_type =&gt; 1 );	// taxonomy management roles are always applied
		else
			$use_taxonomies = scoper_get_otype_option( &#039;use_term_roles&#039;, $src_name, $object_type );

		$taxonomies = array_merge( $taxonomies, array_intersect( (array) $use_taxonomies, array( 1 ) ) );  // array cast prevents PHP warning on first-time execution following update to RS 1.2
	}
	
	if ( $taxonomies ) {
		// make sure we indicate non-usage of term roles for taxonomies that are completely disabled for RS
		if ( &#039;post&#039; == $src_name ) {
			$use_taxonomies = scoper_get_option( &#039;use_taxonomies&#039; );
			$taxonomies = array_intersect_key( $taxonomies, array_intersect( $use_taxonomies, array( 1 ) ) );
		}
		
		return array_keys($taxonomies);
	} else
		return array();
}

function cr_find_post_type( $post_arg = &#039;&#039;, $return_default = true ) {
	// the post argument is already an object.  Just return its post_type property
	if ( is_object( $post_arg ) )
		return $post_arg-&gt;post_type;

	if ( $post_arg ) {
		// post_arg is not an object.  If its value matches global post, use that
		if ( ! empty($GLOBALS[&#039;post&#039;]) &amp;&amp; is_object($GLOBALS[&#039;post&#039;]) &amp;&amp; ( $post_arg == $GLOBALS[&#039;post&#039;]-&gt;ID ) &amp;&amp; ( &#039;revision&#039; != $GLOBALS[&#039;post&#039;]-&gt;post_type ) ) {
			$_type = $GLOBALS[&#039;post&#039;]-&gt;post_type;

			if ( &#039;revision&#039; == $_type )
				$_type = get_post_field( &#039;post_type&#039;, $GLOBALS[&#039;post&#039;]-&gt;post_parent );
		}
			
		// we have a post id but it doesn&#039;t match global post, so retrieve it
		if ( $_post = get_post( $post_arg ) ) {
			$_type = $_post-&gt;post_type;
			
			if ( &#039;revision&#039; == $_type )
				$_type = get_post_field( &#039;post_type&#039;, $_post-&gt;post_parent );
		}
		
		if ( ! empty($_type) )
			return $_type;
	}
	
	// no post id was passed in, or we couldn&#039;t retrieve it for some reason, so check $_REQUEST args
	global $pagenow;

	if ( ! empty( $GLOBALS[&#039;post&#039;] ) &amp;&amp; is_object($GLOBALS[&#039;post&#039;]) &amp;&amp; ! empty( $GLOBALS[&#039;post&#039;]-&gt;post_type ) ) {
		$object_type = $GLOBALS[&#039;post&#039;]-&gt;post_type;

		if ( &#039;revision&#039; == $object_type )
			$object_type = get_post_field( &#039;post_type&#039;, $GLOBALS[&#039;post&#039;]-&gt;post_parent );

	} elseif ( ! empty( $GLOBALS[&#039;wp_query&#039;]-&gt;queried_object ) &amp;&amp; ! empty( $GLOBALS[&#039;wp_query&#039;]-&gt;queried_object-&gt;post_type ) ) {
		$object_type = $GLOBALS[&#039;wp_query&#039;]-&gt;queried_object-&gt;post_type;
		
	} elseif ( ! empty( $GLOBALS[&#039;wp_query&#039;]-&gt;queried_object ) &amp;&amp; ! empty( $GLOBALS[&#039;wp_query&#039;]-&gt;queried_object-&gt;name ) ) {
		$object_type = $GLOBALS[&#039;wp_query&#039;]-&gt;queried_object-&gt;name;
		
	} elseif ( in_array( $pagenow, array( &#039;post-new.php&#039;, &#039;edit.php&#039; ) ) ) {
		$object_type = ! empty( $_GET[&#039;post_type&#039;] ) ? sanitize_key( $_GET[&#039;post_type&#039;] ) : &#039;post&#039;;
		
	} elseif ( in_array( $pagenow, array( &#039;edit-tags.php&#039; ) ) ) {
		$object_type = ! empty( $_GET[&#039;taxonomy&#039;] ) ? sanitize_key( $_GET[&#039;taxonomy&#039;] ) : &#039;category&#039;;

	} elseif ( in_array( $pagenow, array( &#039;admin-ajax.php&#039; ) ) &amp;&amp; ! empty( $_REQUEST[&#039;taxonomy&#039;] ) ) {
		$object_type = sanitize_key( $_REQUEST[&#039;taxonomy&#039;] );
		
	} elseif ( ! empty( $_POST[&#039;post_ID&#039;] ) ) {
		if ( $_post = get_post( $_POST[&#039;post_ID&#039;] ) )
			$object_type = $_post-&gt;post_type;
				
	} elseif ( ! empty( $_GET[&#039;post&#039;] ) ) {	 // post.php
		if ( $_post = get_post( $_GET[&#039;post&#039;] ) )
			$object_type = $_post-&gt;post_type;
	
	} elseif( ! empty( $GLOBALS[&#039;scoper_object_type&#039;] ) ) {
		$object_type = $GLOBALS[&#039;scoper_object_type&#039;];

	} elseif( ! empty($_SERVER) &amp;&amp; is_array($_SERVER) &amp;&amp; isset( $_SERVER[&#039;HTTP_REFERER&#039;] ) &amp;&amp; is_string($_SERVER[&#039;HTTP_REFERER&#039;]) ) {
		if ( $pos = strpos( $_SERVER[&#039;HTTP_REFERER&#039;], &#039;?&#039; ) ) {
			$arg_str = substr( $_SERVER[&#039;HTTP_REFERER&#039;], $pos + 1 );
			$args = wp_parse_args( $arg_str );
	
			if ( ! empty( $args[&#039;post&#039;] ) ) {
				if ( $_post = get_post( $args[&#039;post&#039;] ) ) {
					if ( isset( $_post-&gt;post_type ) ) {
						//rs_errlog( &quot;cr_find_post_type - {$_post-&gt;post_type} from http_referer&quot; );
						return $_post-&gt;post_type;
					}
				}
			}	
		}
	}

	if ( empty($object_type) ) {
		if ( $return_default ) // default to post type
			return &#039;post&#039;;
	} elseif ( &#039;any&#039; != $object_type ) {
		return $object_type;
	}
}

function cr_find_object_type( $src_name, $object = &#039;&#039; ) {
	if ( &#039;post&#039; == $src_name )
		return cr_find_post_type( $object );
	
	global $scoper;
	$src = $scoper-&gt;data_sources-&gt;get( $src_name );
	$object_id = ( is_object($object ) ) ? $src-&gt;cols-&gt;id : $object;

	return sanitize_key( $scoper-&gt;data_sources-&gt;detect( &#039;type&#039;, $src_name, $object_id ) );
}

function cr_get_type_object( $src_name, $object_type ) {
	if ( &#039;post&#039; == $src_name )
		return get_post_type_object( $object_type );
		
	global $scoper;
	return $scoper-&gt;data_sources-&gt;member_property( $src_name, &#039;object_types&#039;, $object_type );
}

function scoper_get_object_id($src_name = &#039;post&#039;, $object_type = &#039;&#039;) {
	global $scoper;
	return (int) $scoper-&gt;data_sources-&gt;detect( &#039;id&#039;, $src_name, 0, $object_type );	
}


function is_administrator_rs( $src_or_tx = &#039;&#039;, $admin_type = &#039;content&#039;, $user = &#039;&#039; ) {
	if ( ! $user ) {
		global $current_user;
		$user = $current_user;
		
		if ( IS_MU_RS &amp;&amp; function_exists(&#039;is_super_admin&#039;) &amp;&amp; is_super_admin() ) {
			return true;
		}
	}

	if ( empty($user-&gt;ID) )
		return false;
		
	$return = &#039;&#039;;

	$admin_cap_name = scoper_get_administrator_cap( $admin_type );
	$return = ! empty( $user-&gt;allcaps[$admin_cap_name] );
	
	if ( ! $return &amp;&amp; $src_or_tx &amp;&amp; ! empty($GLOBALS[&#039;scoper&#039;]) ) {
		if ( ! is_object($src_or_tx) ) {
			global $scoper;
			if ( ! $src_or_tx = $scoper-&gt;data_sources-&gt;get( $src_or_tx ) )
				$src_or_tx = $scoper-&gt;taxonomies-&gt;get( $src_or_tx );
		}
			
		if ( is_object($src_or_tx) &amp;&amp; ! empty($src_or_tx-&gt;defining_module) ) {
			if ( ! in_array( $src_or_tx-&gt;defining_module, array( &#039;role-scoper&#039;, &#039;wordpress&#039;, &#039;wp&#039; ) ) ) {
				// user is not a universal administrator, but are they an administrator for the specified module (plugin-defined data source) ?
				static $admin_caps;
				
				if ( ! isset($admin_caps) )
					$admin_caps = apply_filters( &#039;define_administrator_caps_rs&#039;, array() );
		
				if ( ! empty( $admin_caps[ $src_or_tx-&gt;defining_module ] ) )
					$return = ! empty( $user-&gt;allcaps[ $admin_caps[ $src_or_tx-&gt;defining_module ] ] );
			}
		}
	}
	
	return $return;
}

function is_option_administrator_rs( $user = &#039;&#039; ) {
	return is_administrator_rs( &#039;&#039;, &#039;option&#039;, $user );
}

function is_user_administrator_rs( $user = &#039;&#039; ) {
	return is_administrator_rs( &#039;&#039;, &#039;user&#039;, $user );
} 

function is_content_administrator_rs( $user = &#039;&#039; ) {
	return is_administrator_rs( &#039;&#039;, &#039;content&#039;, $user );
}

function scoper_get_administrator_cap( $admin_type ) {
	if ( ! $admin_type )
		$admin_type = &#039;content&#039;;
	
	// Note: to differentiate content administrator role, define a custom cap such as &quot;administer_all_content&quot;, add it to a custom Role, and add the following line to wp-config.php: define( &#039;SCOPER_CONTENT_ADMIN_CAP&#039;, &#039;cap_name&#039; );
	$default_cap = array( &#039;option&#039; =&gt; &#039;manage_options&#039;, &#039;user&#039; =&gt; &#039;edit_users&#039;, &#039;content&#039; =&gt; &#039;activate_plugins&#039; );

	$constant_name = &#039;SCOPER_&#039; . strtoupper($admin_type) . &#039;_ADMIN_CAP&#039;;
	$cap_name = ( defined( $constant_name ) ) ? constant( $constant_name ) : $default_cap[$admin_type];
	
	if ( &#039;read&#039; == $cap_name )	// avoid catostrophic mistakes
		$cap_name = $default_cap[$admin_type];
		
	return $cap_name;
}

?&gt;</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2F4xpips.net%2Fwp-content%2Foff-plugins%2Frole-scoper'>⬅ Back to Directory</a>