Added _misc.headerVersion. Updated versions mismatch warning.
[py-rsbac] / rsbac / _misc.py
1 # -*- coding:utf-8 -*-
2
3 # py-rsbac - RSBAC Python bindings
4 # Copyright (C) 2006  Frederic Jolliton <pyrsbac@tuxee.net>
5
6 # This program is free software; you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation; either version 2 of the License, or
9 # (at your option) any later version.
10
11 # This program is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 # GNU General Public License for more details.
15
16 # You should have received a copy of the GNU General Public License
17 # along with this program; if not, write to the Free Software
18 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
20 __all__ = []
21
22 from ctypes import c_char, byref, create_string_buffer
23
24 from rsbac import headers, lib
25 from rsbac.errors import raiseIfError
26 from rsbac._utils import aptr
27
28 def export( fun ) :
29     __all__.append( fun.__name__ )
30     return fun
31
32 @export
33 def headerVersion() :
34     """Return the RSBAC header version as a 3-tuple.
35
36     """
37     return ( headers.RSBAC_VERSION_MAJOR ,
38              headers.RSBAC_VERSION_MID ,
39              headers.RSBAC_VERSION_MINOR )
40
41 @export
42 def libraryVersion() :
43     """Return the RSBAC library version as a 3-tuple.
44
45     """
46     from _autodetect import version
47     return version
48
49 @export
50 def kernelVersion() :
51     """Return the RSBAC kernel version as a 3-tuple.
52
53     """
54     v = lib.rsbac_version()
55     v , z = divmod( v , 256 )
56     v , y = divmod( v , 256 )
57     x = v
58     return x , y , z
59
60 @export
61 def dumpStats() :
62     """Dump statistics about RSBAC to kernel log.
63
64     """
65     return raiseIfError( lib.rsbac_stats() )
66
67 @export
68 def checkConsistency( correct , checkInode ) :
69     """Consistency checking (as far as possible)
70
71     correct = 0: do not correct errors
72     correct = 1: correct errors
73     correct = 2: correct more
74     checkInode = 0: do not check inode numbers
75     checkInode = 1: also check inode numbers (only ext2/3 on 2.4 kernels)
76
77     """
78     return raiseIfError( lib.rsbac_check( correct , checkInode ) )
79
80 @export
81 def writeDirtyLists() :
82     """Write all dirty lists to disk. Returns number of lists written.
83
84     """
85     return raiseIfError( lib.rsbac_write() )
86
87 def _rsbacLog( type , size = None ) :
88     if type in ( 2 , 3 , 4 ) :
89         if size is None :
90             size = 4096
91         buffer = ( c_char * size )()
92         raiseIfError( lib.rsbac_log( type , aptr( buffer ) , size ) )
93         return buffer.value
94     else :
95         return raiseIfError( lib.rsbac_log( type , None , 0 ) )
96
97 @export
98 def openLog() :
99     """Open RSBAC log (Warning: no-op)
100
101     """
102     return _rsbacLog( 1 )
103
104 @export
105 def closeLog() :
106     """Close RSBAC log (Warning: no-op)
107
108     """
109     return _rsbacLog( 0 )
110
111 @export
112 def readLog( size = 4096 ) :
113     """Read RSBAC log.
114
115     """
116     return _rsbacLog( 2 , size )
117
118 @export
119 def readRingBuffer( size = 4096 ) :
120     """Read the ring buffer.
121
122     """
123     return _rsbacLog( 3 , size )
124
125 @export
126 def readAndClearRingBuffer( size = 4096 ) :
127     """Read and clear the ring buffer.
128
129     """
130     return _rsbacLog( 4 , size )
131
132 @export
133 def clearRingBuffer() :
134     """Clear the ring buffer.
135
136     """
137     return _rsbacLog( 5 )
138
139 @export
140 def init( path ) :
141     """Initialize a filesystem with RSBAC.
142
143     """
144     return raiseIfError( lib.rsbac_init( path ) )
145
146 #--[ getname ]----------------------------------------------------------------
147
148 g_nameBuffer = create_string_buffer( 65536 )
149
150 #
151 # This function creates 3 functions to wrap get_XX_name and get_XX_nr
152 # RSBAC functions. The resulting functions are named getXxxName,
153 # getXxxNames and getXxxNumber.
154 #
155 # __makeGetNameFunctions( 'Foo' , 'foo' , .. ) creates
156 # getFooName(value), getFooNames(), getFooNumber(name)
157 #
158 def __makeGetNameFunctions( name , fname , limit ) :
159     byName = getattr( lib , 'get_' + fname + '_name' )
160     byNumber = getattr( lib , 'get_' + fname + '_nr' )
161     names = []
162     def getName( value ) :
163         if 0 <= value < limit :
164             return byName( g_nameBuffer , value )
165     def getNames() :
166         if not names :
167             names[ : ] = map( getName , range( limit ) )
168         return names
169     def getNumber( name ) :
170         result = byNumber( name )
171         if getName( result ) == name :
172             return result
173     import sys
174     m = sys.modules[ __name__ ]
175     a = 'get' + name + 'Name'
176     b = 'get' + name + 'Names'
177     c = 'get' + name + 'Number'
178     setattr( m , a , getName )
179     setattr( m , b , getNames )
180     setattr( m , c , getNumber )
181     __all__.extend( [ a , b , c ] )
182
183 # getname.c
184
185 __makeGetNameFunctions( 'Request' , 'request' , headers.R_NONE )
186 __makeGetNameFunctions( 'Result' , 'result' , headers.UNDEFINED + 1 )
187
188 @export
189 def getAttributeModule( attribute ) :
190     if 0 <= attribute <= headers.A_none :
191         return lib.get_attr_module( attribute )
192
193 __makeGetNameFunctions( 'Attribute' , 'attribute' , headers.A_none + 1 )
194
195 # def getAttributeValueName( .. ) : pass
196
197 __makeGetNameFunctions( 'ScdType' , 'scd_type' , headers.ST_none + 1 )
198
199 # We choose the following mapping:
200 # get_target_name -> getTargetNameFull
201 # get_target_name_only -> getTargetName
202
203 # def getTargetNameFull( .. ) : pass
204
205 # FIXME: Update __makeGetNameFunctions to handle this. (Allowing to
206 # use an alternative suffix.)
207 @export
208 def getTargetName( target ) :
209     if 0 <= target <= headers.T_NONE :
210         return lib.get_target_name_only( g_nameBuffer , target )
211
212 @export
213 def getTargetNames( __r = [] ) :
214     if not __r :
215         __r[ : ] = map( getTargetName , range( headers.T_NONE + 1 ) )
216     return __r
217
218 @export
219 def getTargetNumber( name ) :
220     target = lib.get_target_nr( name )
221     if getTargetName( target ) == name :
222         return target
223
224 __makeGetNameFunctions( 'IpcTarget' , 'ipc_target' , headers.I_none + 1 )
225 __makeGetNameFunctions( 'SwitchTarget' , 'switch_target' , headers.SW_NONE + 1 )
226
227 @export
228 def getErrorName( error ) :
229     return lib.get_error_name( g_nameBuffer , error )
230
231 @export
232 def getAttributeParameters( attribute ) :
233     if 0 <= attribute <= headers.A_none :
234         return lib.get_attribute_param( g_nameBuffer , attribute )
235
236 __makeGetNameFunctions( 'LogLevel' , 'log_level' , headers.LL_invalid + 1 )
237
238 @export
239 def getCapName( value ) :
240     name = lib.get_cap_name( g_nameBuffer , value )
241     if name != 'ERROR!' :
242         return name
243
244 @export
245 def getCapNames( __r = [] ) :
246     if not __r :
247         i = 0
248         while 1 :
249             name = getCapName( i )
250             if not name :
251                 break
252             __r.append( name )
253             i += 1
254     return __r
255
256 @export
257 def getCapNumber( name ) :
258     value = lib.get_cap_nr( name )
259     if getCapName( value ) == name :
260         return value
261
262 # rc_getname.c
263
264 __makeGetNameFunctions( 'RcTarget' , 'rc_target' , headers.RT_NONE + 1 )
265 __makeGetNameFunctions( 'RcAdmin' , 'rc_admin' , headers.RC_none + 1 )
266
267 @export
268 def getRcScdTypeName( value ) :
269     name = lib.get_rc_scd_type_name( g_nameBuffer , value )
270     if name != 'ERROR!' :
271         return name
272
273 @export
274 def getRcScdTypeNames( __r = [] ) :
275     if not __r :
276         __r[ : ] = map( getRcScdTypeName , range( headers.RST_none + 1 ) )
277     return __r
278
279 @export
280 def getRcScdTypeNumber( name ) :
281     value = lib.get_rc_scd_type_nr( name )
282     if getRcScdTypeName( value ) == name :
283         return value
284
285 __makeGetNameFunctions( 'RcItem' , 'rc_item' , headers.RI_none + 1 )
286
287 @export
288 def getRcItemParameters( value ) :
289     if 0 <= value <= headers.RI_none :
290         return lib.get_rc_item_param( g_nameBuffer , value )
291
292 @export
293 def getRcSpecialRightName( value ) :
294     name = lib.get_rc_special_right_name( g_nameBuffer , value )
295     if name != 'ERROR!' :
296         return name
297
298 @export
299 def getRcSpecialRightNames( __r = [] ) :
300     if not __r :
301         __r[ : ] = map( getRcSpecialRightName , range( headers.RCR_NONE + 1 ) )
302     return __r
303
304 @export
305 def getRcSpecialRightNumber( name ) :
306     value = lib.get_rc_special_right_nr( name )
307     if getRcSpecialRightName( value ) == name :
308         return value
309
310 # res_getname.c
311
312 @export
313 def getRessourceName( value ) :
314     name = lib.get_res_name( g_nameBuffer , value )
315     if name != 'ERROR!' :
316         return name
317
318 @export
319 def getRessourceNames( __r = [] ) :
320     if not __r :
321         i = 0
322         while 1 :
323             name = getRessourceName( i )
324             if not name :
325                 break
326             __r.append( name )
327             i += 1
328     return __r
329
330 @export
331 def getRessourceNumber( name ) :
332     value = lib.get_res_nr( name )
333     if getRessourceName( value ) == name :
334         return value
335
336 # Local Variables:
337 # indent-tabs-mode: nil
338 # python-indent: 4
339 # End: