php_library/fboprime/perm.inc

<?php
//$Header: /hl/cvsroots/gpl01/gpl01/webprojs/fboprime/sw/phplib/perm.inc,v 1.5 2006/07/03 03:46:24 dashley Exp $
//--------------------------------------------------------------------------------------------------------------
//perm.inc--FboPrime User Permission String Processing
//Copyright (C) 2006  David T. Ashley
//
//This program is free software; you can redistribute it and/or
//modify it under the terms of the GNU General Public License
//as published by the Free Software Foundation; either version 2
//of the License, or (at your option) any later version.
//
//This program is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with this program; if not, write to the Free Software
//Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
//********************************************************************************
//This includes functions used to process user permission strings, and explains
//the format of permission strings (but not textual descriptions of what the
//variables mean or the semantics).  For explanation of the semantics of the 
//permission string variables, please see permview.inc.
//--------------------------------------------------------------------------------------------------------------
require_once("global.inc");
require_once("strfunc.inc");
//
//--------------------------------------------------------------------------------------------------------------
//Format of an individual permission:
//  a)Begins with a single backslash.
//  b)Followed by at least one letter of either case (parameter names are case-sensitive).
//  c)Followed by aribitrarily many letters and numbers.
//  d)Followed by "=".
//  e)Followed by a quotation mark.
//  f)Followed by the actual parameter--only spaces, letters, hyphens, periods, and numbers are allowed.
//    The empty string is allowed.
//  g)Concluded by another quotation mark.
//
//Format of a permission string:
//  a)Simple concatenation of aribitrarily many individual permissions as described above.
//
//The format in general is designed for rapid search.  The string functions will find parameter
//names quite quickly.
//--------------------------------------------------------------------------------------------------------------
//Retrieves the value of a parameter within a string, or FALSE if the parameter does not
//exist in the string.
//
//The permission string must be properly formatted.
//
//Unit-tested 20060427.
//
function PERM_get_val_from_string($permstring, $permname)
   {
   $idx = strpos($permstring, "\\" . $permname . "=");

   if ($idx === FALSE)
      {
      //Value not found.  Indicate this to the caller with FALSE.
      return(FALSE);
      }
   else
      {
      //Value was found.
      $len = strlen($permstring);  //Record the length for efficiency.

      //Grab the offset of the two quotes following the parameter name.
      $q1pos = FALSE;
      $q2pos = FALSE;
      $q1pos = strpos($permstring, "\"", $idx);
      if (($q1pos !== FALSE) && ($q1pos < ($len-1)))
         $q2pos = strpos($permstring, "\"", $q1pos + 1);

      //Return the appropriate result.
      if (($q1pos !== FALSE) && ($q2pos !== FALSE))
         {
         //We have a properly-quoted result.  Return it.
         return(SubStr($permstring, $q1pos+1, $q2pos-$q1pos-1));
         }
      else
         {
         //Something went wrong.  Return FALSE.
         return(FALSE);
         }
      }
   }
//
//--------------------------------------------------------------------------------------------------------------
//Splits a permission string into its components, and returns an associative array containing the permission
//string names as the keys and the values as the elements.
//
//If there are no permissions in the string, returns FALSE.
//
//The string should be a properly-formatted permission string.
//
//If the are multiple entries in the string, the later value will be written
//over the earlier one in the associative array.
//
//Unit-tested 20060427.
//
function PERM_split_aa($arg)
   {
   $temp = explode("\\", $arg);

   if ($temp === FALSE)
      {
      return(FALSE);
      }
   else if (count($temp) == 0)
      {
      return(FALSE);
      }
   else
      {
      $putidx = 0;

      for ($i=0; $i<count($temp); $i++)
         {
         $val = $temp[$i];
         $len = strlen($val);

         if ($len >= 4)
            {
            $q1pos = FALSE;
            $q2pos = FALSE;
            $q1pos = strpos($val, "\"");
            if (($q1pos !== FALSE) && ($q1pos < ($len-1)))
               $q2pos = strpos($val, "\"", $q1pos + 1);

            if (($q1pos !== FALSE) && ($q2pos !== FALSE) && ($q1pos >= 2))
               {
               $rv[SubStr($val, 0, $q1pos-1)] = SubStr($val, $q1pos+1, $q2pos-$q1pos-1);
               $putidx++;
               }
            }
         }

      //Unless we couldn't find anything seemingly valid, return the array.
      if ($putidx > 0)
         return($rv);
      else
         return(FALSE);
      }
   }
//
//--------------------------------------------------------------------------------------------------------------
//Recombines a permission string that has been split from an associative array into a permission string.
//No hard error checking is performed, i.e. array names with invalid characters or strings with invalid
//characters will slip through in the interest of speed.
//
function PERM_combine_aa($arg)
   {
   $rv = "";

   reset($arg);
   while (list($key, $val) = each($arg))
      {
      $rv = $rv . "\\" . $key . "=\"" . $val . "\"";
      }

   return($rv);
   }
//
//--------------------------------------------------------------------------------------------------------------
//Recombines a permission string that has been split from an associative array into a permission string.
//All invalid characters are stripped from both key names and values (and empty keys are dropped), leading
//to a guaranteed valid permission string.  This function is naturally slower than the function above because
//of the error checking.
//
function PERM_combine_aa_error_trap($arg)
   {   
   $rv = "";

   //Since we're doing an expensive operation, might as well sort the array, too.
   ksort($arg);

   reset($arg);
   while (list($key, $val) = each($arg))
      {
      if (strlen($key) > 0)  //Don't want to go further if key is empty.
         {
         //Force the string into numbers and letters for the key.
         $key = STRFUNC_force_into_subset($key, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
         
         //It is still possible that the first character is a digit, which is a no-no.
         //Rip characters off the string until we have either a letter or an empty string.
         while ((strlen($key) > 0) && (strpos("0123456789", SubStr($key, 0, 1)) !== FALSE))
            {
            $key = SubStr($key, 1, strlen($key) - 1);  //Rip the character off the front.
            }

         //If we have an empty string, don't proceed.
         if (strlen($key) > 0)
            {
            //Force the value into the allowable character set.
            $val = STRFUNC_force_into_subset($val, " abcdefghijklmnopqrstuvwxyz-.ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");

            //Add to the string.
            $rv = $rv . "\\" . $key . "=\"" . $val . "\"";
            }
         }
      }

   return($rv);
   }
//
//--------------------------------------------------------------------------------------------------------------
//Forces a permission string into valid space.
//
//This can be done inefficiently by just splitting and then recombining.
//
//Unit-tested 20060427.
//
function PERM_force_into_valid_space($arg)
   {
   $splitval = PERM_split_aa($arg);               //Split it.
   $rv = PERM_combine_aa_error_trap($splitval);   //Recombine it.

   //Return value to caller.
   return($rv);
   }
//
//--------------------------------------------------------------------------------------------------------------
//End of $RCSfile: perm.inc,v $.
//--------------------------------------------------------------------------------------------------------------
?>
1	dashley	35	<?php
2			//$Header: /hl/cvsroots/gpl01/gpl01/webprojs/fboprime/sw/phplib/perm.inc,v 1.5 2006/07/03 03:46:24 dashley Exp $
3			//--------------------------------------------------------------------------------------------------------------
4			//perm.inc--FboPrime User Permission String Processing
5			//Copyright (C) 2006 David T. Ashley
6			//
7			//This program is free software; you can redistribute it and/or
8			//modify it under the terms of the GNU General Public License
9			//as published by the Free Software Foundation; either version 2
10			//of the License, or (at your option) any later version.
11			//
12			//This program is distributed in the hope that it will be useful,
13			//but WITHOUT ANY WARRANTY; without even the implied warranty of
14			//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			//GNU General Public License for more details.
16			//
17			//You should have received a copy of the GNU General Public License
18			//along with this program; if not, write to the Free Software
19			//Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20			//********************************************************************************
21			//This includes functions used to process user permission strings, and explains
22			//the format of permission strings (but not textual descriptions of what the
23			//variables mean or the semantics). For explanation of the semantics of the
24			//permission string variables, please see permview.inc.
25			//--------------------------------------------------------------------------------------------------------------
26			require_once("global.inc");
27			require_once("strfunc.inc");
28			//
29			//--------------------------------------------------------------------------------------------------------------
30			//Format of an individual permission:
31			// a)Begins with a single backslash.
32			// b)Followed by at least one letter of either case (parameter names are case-sensitive).
33			// c)Followed by aribitrarily many letters and numbers.
34			// d)Followed by "=".
35			// e)Followed by a quotation mark.
36			// f)Followed by the actual parameter--only spaces, letters, hyphens, periods, and numbers are allowed.
37			// The empty string is allowed.
38			// g)Concluded by another quotation mark.
39			//
40			//Format of a permission string:
41			// a)Simple concatenation of aribitrarily many individual permissions as described above.
42			//
43			//The format in general is designed for rapid search. The string functions will find parameter
44			//names quite quickly.
45			//--------------------------------------------------------------------------------------------------------------
46			//Retrieves the value of a parameter within a string, or FALSE if the parameter does not
47			//exist in the string.
48			//
49			//The permission string must be properly formatted.
50			//
51			//Unit-tested 20060427.
52			//
53			function PERM_get_val_from_string($permstring, $permname)
54			{
55			$idx = strpos($permstring, "\\" . $permname . "=");
56
57			if ($idx === FALSE)
58			{
59			//Value not found. Indicate this to the caller with FALSE.
60			return(FALSE);
61			}
62			else
63			{
64			//Value was found.
65			$len = strlen($permstring); //Record the length for efficiency.
66
67			//Grab the offset of the two quotes following the parameter name.
68			$q1pos = FALSE;
69			$q2pos = FALSE;
70			$q1pos = strpos($permstring, "\"", $idx);
71			if (($q1pos !== FALSE) && ($q1pos < ($len-1)))
72			$q2pos = strpos($permstring, "\"", $q1pos + 1);
73
74			//Return the appropriate result.
75			if (($q1pos !== FALSE) && ($q2pos !== FALSE))
76			{
77			//We have a properly-quoted result. Return it.
78			return(SubStr($permstring, $q1pos+1, $q2pos-$q1pos-1));
79			}
80			else
81			{
82			//Something went wrong. Return FALSE.
83			return(FALSE);
84			}
85			}
86			}
87			//
88			//--------------------------------------------------------------------------------------------------------------
89			//Splits a permission string into its components, and returns an associative array containing the permission
90			//string names as the keys and the values as the elements.
91			//
92			//If there are no permissions in the string, returns FALSE.
93			//
94			//The string should be a properly-formatted permission string.
95			//
96			//If the are multiple entries in the string, the later value will be written
97			//over the earlier one in the associative array.
98			//
99			//Unit-tested 20060427.
100			//
101			function PERM_split_aa($arg)
102			{
103			$temp = explode("\\", $arg);
104
105			if ($temp === FALSE)
106			{
107			return(FALSE);
108			}
109			else if (count($temp) == 0)
110			{
111			return(FALSE);
112			}
113			else
114			{
115			$putidx = 0;
116
117			for ($i=0; $i<count($temp); $i++)
118			{
119			$val = $temp[$i];
120			$len = strlen($val);
121
122			if ($len >= 4)
123			{
124			$q1pos = FALSE;
125			$q2pos = FALSE;
126			$q1pos = strpos($val, "\"");
127			if (($q1pos !== FALSE) && ($q1pos < ($len-1)))
128			$q2pos = strpos($val, "\"", $q1pos + 1);
129
130			if (($q1pos !== FALSE) && ($q2pos !== FALSE) && ($q1pos >= 2))
131			{
132			$rv[SubStr($val, 0, $q1pos-1)] = SubStr($val, $q1pos+1, $q2pos-$q1pos-1);
133			$putidx++;
134			}
135			}
136			}
137
138			//Unless we couldn't find anything seemingly valid, return the array.
139			if ($putidx > 0)
140			return($rv);
141			else
142			return(FALSE);
143			}
144			}
145			//
146			//--------------------------------------------------------------------------------------------------------------
147			//Recombines a permission string that has been split from an associative array into a permission string.
148			//No hard error checking is performed, i.e. array names with invalid characters or strings with invalid
149			//characters will slip through in the interest of speed.
150			//
151			function PERM_combine_aa($arg)
152			{
153			$rv = "";
154
155			reset($arg);
156			while (list($key, $val) = each($arg))
157			{
158			$rv = $rv . "\\" . $key . "=\"" . $val . "\"";
159			}
160
161			return($rv);
162			}
163			//
164			//--------------------------------------------------------------------------------------------------------------
165			//Recombines a permission string that has been split from an associative array into a permission string.
166			//All invalid characters are stripped from both key names and values (and empty keys are dropped), leading
167			//to a guaranteed valid permission string. This function is naturally slower than the function above because
168			//of the error checking.
169			//
170			function PERM_combine_aa_error_trap($arg)
171			{
172			$rv = "";
173
174			//Since we're doing an expensive operation, might as well sort the array, too.
175			ksort($arg);
176
177			reset($arg);
178			while (list($key, $val) = each($arg))
179			{
180			if (strlen($key) > 0) //Don't want to go further if key is empty.
181			{
182			//Force the string into numbers and letters for the key.
183			$key = STRFUNC_force_into_subset($key, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
184
185			//It is still possible that the first character is a digit, which is a no-no.
186			//Rip characters off the string until we have either a letter or an empty string.
187			while ((strlen($key) > 0) && (strpos("0123456789", SubStr($key, 0, 1)) !== FALSE))
188			{
189			$key = SubStr($key, 1, strlen($key) - 1); //Rip the character off the front.
190			}
191
192			//If we have an empty string, don't proceed.
193			if (strlen($key) > 0)
194			{
195			//Force the value into the allowable character set.
196			$val = STRFUNC_force_into_subset($val, " abcdefghijklmnopqrstuvwxyz-.ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
197
198			//Add to the string.
199			$rv = $rv . "\\" . $key . "=\"" . $val . "\"";
200			}
201			}
202			}
203
204			return($rv);
205			}
206			//
207			//--------------------------------------------------------------------------------------------------------------
208			//Forces a permission string into valid space.
209			//
210			//This can be done inefficiently by just splitting and then recombining.
211			//
212			//Unit-tested 20060427.
213			//
214			function PERM_force_into_valid_space($arg)
215			{
216			$splitval = PERM_split_aa($arg); //Split it.
217			$rv = PERM_combine_aa_error_trap($splitval); //Recombine it.
218
219			//Return value to caller.
220			return($rv);
221			}
222			//
223			//--------------------------------------------------------------------------------------------------------------
224			//End of $RCSfile: perm.inc,v $.
225			//--------------------------------------------------------------------------------------------------------------
226			?>