• Skip to content
  • Skip to link menu
Trinity API Reference
  • Trinity API Reference
  • tdeio/tdeio
 

tdeio/tdeio

  • tdeio
  • tdeio
kacl.cpp
1/* This file is part of the KDE project
2 Copyright (C) 2005 Till Adam <adam@kde.org>
3
4 This library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public
6 License as published by the Free Software Foundation; either
7 version 2 of the License, or (at your option) any later version.
8
9 This library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public License
15 along with this library; see the file COPYING.LIB. If not, write to
16 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17 Boston, MA 02110-1301, USA.
18*/
19// $Id: kacl.cpp 424977 2005-06-13 15:13:22Z tilladam $
20
21#ifdef HAVE_CONFIG_H
22#include <config.h>
23#endif
24
25#include <sys/types.h>
26#include <pwd.h>
27#include <grp.h>
28#include <sys/stat.h>
29#ifdef USE_POSIX_ACL
30#ifdef HAVE_NON_POSIX_ACL_EXTENSIONS
31#include <acl/libacl.h>
32#else
33#include <posixacladdons.h>
34#endif
35#endif
36#include <tqintdict.h>
37
38#include <kdebug.h>
39
40#include "kacl.h"
41
42
43#ifdef USE_POSIX_ACL
44static void printACL( acl_t acl, const TQString &comment );
45static TQString aclAsString(const acl_t acl);
46#endif
47
48class KACL::KACLPrivate {
49public:
50 KACLPrivate() : m_acl( 0 ) { init(); }
51#ifdef USE_POSIX_ACL
52 KACLPrivate( acl_t acl )
53 : m_acl( acl ) { init(); }
54 ~KACLPrivate() { if ( m_acl ) acl_free( m_acl ); }
55#endif
56 void init() {
57 m_usercache.setAutoDelete( true );
58 m_groupcache.setAutoDelete( true );
59 }
60 // helpers
61#ifdef USE_POSIX_ACL
62 bool setMaskPermissions( unsigned short v );
63 TQString getUserName( uid_t uid ) const;
64 TQString getGroupName( gid_t gid ) const;
65 bool setAllUsersOrGroups( const TQValueList< TQPair<TQString, unsigned short> > &list, acl_tag_t type );
66 bool setNamedUserOrGroupPermissions( const TQString& name, unsigned short permissions, acl_tag_t type );
67
68 acl_t m_acl;
69#else
70 int m_acl;
71#endif
72 mutable TQIntDict<TQString> m_usercache;
73 mutable TQIntDict<TQString> m_groupcache;
74};
75
76KACL::KACL( const TQString &aclString )
77 : d( new KACLPrivate )
78{
79 setACL( aclString );
80}
81
82KACL::KACL( mode_t basePermissions )
83#ifdef USE_POSIX_ACL
84 : d( new KACLPrivate( acl_from_mode( basePermissions ) ) )
85#else
86 : d( new KACLPrivate )
87#endif
88{
89#ifndef USE_POSIX_ACL
90 Q_UNUSED( basePermissions );
91#endif
92}
93
94KACL::KACL()
95 : d( new KACLPrivate )
96{
97}
98
99KACL::KACL( const KACL& rhs )
100 : d( new KACLPrivate )
101{
102 setACL( rhs.asString() );
103}
104
105KACL::~KACL()
106{
107 delete d;
108}
109
110bool KACL::operator==( const KACL& rhs ) const {
111#ifdef USE_POSIX_ACL
112 return ( acl_cmp( d->m_acl, rhs.d->m_acl ) == 0 );
113#else
114 Q_UNUSED( rhs );
115 return true;
116#endif
117}
118
119bool KACL::isValid() const
120{
121 bool valid = false;
122#ifdef USE_POSIX_ACL
123 if ( d->m_acl ) {
124 valid = ( acl_valid( d->m_acl ) == 0 );
125 }
126#endif
127 return valid;
128}
129
130bool KACL::isExtended() const
131{
132#ifdef USE_POSIX_ACL
133 return ( acl_equiv_mode( d->m_acl, NULL ) != 0 );
134#else
135 return false;
136#endif
137}
138
139#ifdef USE_POSIX_ACL
140static acl_entry_t entryForTag( acl_t acl, acl_tag_t tag )
141{
142 acl_entry_t entry;
143 int ret = acl_get_entry( acl, ACL_FIRST_ENTRY, &entry );
144 while ( ret == 1 ) {
145 acl_tag_t currentTag;
146 acl_get_tag_type( entry, &currentTag );
147 if ( currentTag == tag )
148 return entry;
149 ret = acl_get_entry( acl, ACL_NEXT_ENTRY, &entry );
150 }
151 return 0;
152}
153
154static unsigned short entryToPermissions( acl_entry_t entry )
155{
156 if ( entry == 0 ) return 0;
157 acl_permset_t permset;
158 if ( acl_get_permset( entry, &permset ) != 0 ) return 0;
159 return( acl_get_perm( permset, ACL_READ ) << 2 |
160 acl_get_perm( permset, ACL_WRITE ) << 1 |
161 acl_get_perm( permset, ACL_EXECUTE ) );
162}
163
164static void permissionsToEntry( acl_entry_t entry, unsigned short v )
165{
166 if ( entry == 0 ) return;
167 acl_permset_t permset;
168 if ( acl_get_permset( entry, &permset ) != 0 ) return;
169 acl_clear_perms( permset );
170 if ( v & 4 ) acl_add_perm( permset, ACL_READ );
171 if ( v & 2 ) acl_add_perm( permset, ACL_WRITE );
172 if ( v & 1 ) acl_add_perm( permset, ACL_EXECUTE );
173}
174
175static void printACL( acl_t acl, const TQString &comment )
176{
177 kdDebug() << comment << aclAsString( acl ) << endl;
178}
179
180static int getUidForName( const TQString& name )
181{
182 struct passwd *user = getpwnam( name.latin1() );
183 if ( user )
184 return user->pw_uid;
185 else
186 return -1;
187}
188
189static int getGidForName( const TQString& name )
190{
191 struct group *group = getgrnam( name.latin1() );
192 if ( group )
193 return group->gr_gid;
194 else
195 return -1;
196}
197#endif
198// ------------------ begin API implementation ------------
199
200unsigned short KACL::ownerPermissions() const
201{
202#ifdef USE_POSIX_ACL
203 return entryToPermissions( entryForTag( d->m_acl, ACL_USER_OBJ ) );
204#else
205 return 0;
206#endif
207}
208
209bool KACL::setOwnerPermissions( unsigned short v )
210{
211#ifdef USE_POSIX_ACL
212 permissionsToEntry( entryForTag( d->m_acl, ACL_USER_OBJ ), v );
213#else
214 Q_UNUSED( v );
215#endif
216 return true;
217}
218
219unsigned short KACL::owningGroupPermissions() const
220{
221#ifdef USE_POSIX_ACL
222 return entryToPermissions( entryForTag( d->m_acl, ACL_GROUP_OBJ ) );
223#else
224 return 0;
225#endif
226}
227
228bool KACL::setOwningGroupPermissions( unsigned short v )
229{
230#ifdef USE_POSIX_ACL
231 permissionsToEntry( entryForTag( d->m_acl, ACL_GROUP_OBJ ), v );
232#else
233 Q_UNUSED( v );
234#endif
235 return true;
236}
237
238unsigned short KACL::othersPermissions() const
239{
240#ifdef USE_POSIX_ACL
241 return entryToPermissions( entryForTag( d->m_acl, ACL_OTHER ) );
242#else
243 return 0;
244#endif
245}
246
247bool KACL::setOthersPermissions( unsigned short v )
248{
249#ifdef USE_POSIX_ACL
250 permissionsToEntry( entryForTag( d->m_acl, ACL_OTHER ), v );
251#else
252 Q_UNUSED( v );
253#endif
254 return true;
255}
256
257mode_t KACL::basePermissions() const
258{
259 mode_t perms( 0 );
260#ifdef USE_POSIX_ACL
261 if ( ownerPermissions() & ACL_READ ) perms |= S_IRUSR;
262 if ( ownerPermissions() & ACL_WRITE ) perms |= S_IWUSR;
263 if ( ownerPermissions() & ACL_EXECUTE ) perms |= S_IXUSR;
264 if ( owningGroupPermissions() & ACL_READ ) perms |= S_IRGRP;
265 if ( owningGroupPermissions() & ACL_WRITE ) perms |= S_IWGRP;
266 if ( owningGroupPermissions() & ACL_EXECUTE ) perms |= S_IXGRP;
267 if ( othersPermissions() & ACL_READ ) perms |= S_IROTH;
268 if ( othersPermissions() & ACL_WRITE ) perms |= S_IWOTH;
269 if ( othersPermissions() & ACL_EXECUTE ) perms |= S_IXOTH;
270#endif
271 return perms;
272}
273
274unsigned short KACL::maskPermissions( bool &exists ) const
275{
276 exists = true;
277#ifdef USE_POSIX_ACL
278 acl_entry_t entry = entryForTag( d->m_acl, ACL_MASK );
279 if ( entry == 0 ) {
280 exists = false;
281 return 0;
282 }
283 return entryToPermissions( entry );
284#else
285 return 0;
286#endif
287}
288
289#ifdef USE_POSIX_ACL
290bool KACL::KACLPrivate::setMaskPermissions( unsigned short v )
291{
292 acl_entry_t entry = entryForTag( m_acl, ACL_MASK );
293 if ( entry == 0 ) {
294 acl_create_entry( &m_acl, &entry );
295 acl_set_tag_type( entry, ACL_MASK );
296 }
297 permissionsToEntry( entry, v );
298 return true;
299}
300#endif
301
302bool KACL::setMaskPermissions( unsigned short v )
303{
304#ifdef USE_POSIX_ACL
305 return d->setMaskPermissions( v );
306#else
307 Q_UNUSED( v );
308 return true;
309#endif
310}
311
312/**************************
313 * Deal with named users *
314 **************************/
315unsigned short KACL::namedUserPermissions( const TQString& name, bool *exists ) const
316{
317#ifdef USE_POSIX_ACL
318 acl_entry_t entry;
319 uid_t id;
320 *exists = false;
321 int ret = acl_get_entry( d->m_acl, ACL_FIRST_ENTRY, &entry );
322 while ( ret == 1 ) {
323 acl_tag_t currentTag;
324 acl_get_tag_type( entry, &currentTag );
325 if ( currentTag == ACL_USER ) {
326 id = *( (uid_t*) acl_get_qualifier( entry ) );
327 if ( d->getUserName( id ) == name ) {
328 *exists = true;
329 return entryToPermissions( entry );
330 }
331 }
332 ret = acl_get_entry( d->m_acl, ACL_NEXT_ENTRY, &entry );
333 }
334#else
335 Q_UNUSED( name );
336 Q_UNUSED( exists );
337#endif
338 return 0;
339}
340
341#ifdef USE_POSIX_ACL
342bool KACL::KACLPrivate::setNamedUserOrGroupPermissions( const TQString& name, unsigned short permissions, acl_tag_t type )
343{
344 bool allIsWell = true;
345 acl_t newACL = acl_dup( m_acl );
346 acl_entry_t entry;
347 bool createdNewEntry = false;
348 bool found = false;
349 int ret = acl_get_entry( newACL, ACL_FIRST_ENTRY, &entry );
350 while ( ret == 1 ) {
351 acl_tag_t currentTag;
352 acl_get_tag_type( entry, &currentTag );
353 if ( currentTag == type ) {
354 int id = * (int*)acl_get_qualifier( entry );
355 const TQString entryName = type == ACL_USER? getUserName( id ): getGroupName( id );
356 if ( entryName == name ) {
357 // found him, update
358 permissionsToEntry( entry, permissions );
359 found = true;
360 break;
361 }
362 }
363 ret = acl_get_entry( newACL, ACL_NEXT_ENTRY, &entry );
364 }
365 if ( !found ) {
366 acl_create_entry( &newACL, &entry );
367 acl_set_tag_type( entry, type );
368 int id = type == ACL_USER? getUidForName( name ): getGidForName( name );
369 if ( id == -1 || acl_set_qualifier( entry, &id ) != 0 ) {
370 acl_delete_entry( newACL, entry );
371 allIsWell = false;
372 } else {
373 permissionsToEntry( entry, permissions );
374 createdNewEntry = true;
375 }
376 }
377 if ( allIsWell && createdNewEntry ) {
378 // 23.1.1 of 1003.1e states that as soon as there is a named user or
379 // named group entry, there needs to be a mask entry as well, so add
380 // one, if the user hasn't explicitely set one.
381 if ( entryForTag( newACL, ACL_MASK ) == 0 ) {
382 acl_calc_mask( &newACL );
383 }
384 }
385
386 if ( !allIsWell || acl_valid( newACL ) != 0 ) {
387 acl_free( newACL );
388 allIsWell = false;
389 } else {
390 acl_free( m_acl );
391 m_acl = newACL;
392 }
393 return allIsWell;
394}
395#endif
396
397bool KACL::setNamedUserPermissions( const TQString& name, unsigned short permissions )
398{
399#ifdef USE_POSIX_ACL
400 return d->setNamedUserOrGroupPermissions( name, permissions, ACL_USER );
401#else
402 Q_UNUSED( name );
403 Q_UNUSED( permissions );
404 return true;
405#endif
406}
407
408ACLUserPermissionsList KACL::allUserPermissions() const
409{
410 ACLUserPermissionsList list;
411#ifdef USE_POSIX_ACL
412 acl_entry_t entry;
413 uid_t id;
414 int ret = acl_get_entry( d->m_acl, ACL_FIRST_ENTRY, &entry );
415 while ( ret == 1 ) {
416 acl_tag_t currentTag;
417 acl_get_tag_type( entry, &currentTag );
418 if ( currentTag == ACL_USER ) {
419 id = *( (uid_t*) acl_get_qualifier( entry ) );
420 TQString name = d->getUserName( id );
421 unsigned short permissions = entryToPermissions( entry );
422 ACLUserPermissions pair = qMakePair( name, permissions );
423 list.append( pair );
424 }
425 ret = acl_get_entry( d->m_acl, ACL_NEXT_ENTRY, &entry );
426 }
427#endif
428 return list;
429}
430
431#ifdef USE_POSIX_ACL
432bool KACL::KACLPrivate::setAllUsersOrGroups( const TQValueList< TQPair<TQString, unsigned short> > &list, acl_tag_t type )
433{
434 bool allIsWell = true;
435 bool atLeastOneUserOrGroup = false;
436
437 // make working copy, in case something goes wrong
438 acl_t newACL = acl_dup( m_acl );
439 acl_entry_t entry;
440
441//printACL( newACL, "Before cleaning: " );
442 // clear user entries
443 int ret = acl_get_entry( newACL, ACL_FIRST_ENTRY, &entry );
444 while ( ret == 1 ) {
445 acl_tag_t currentTag;
446 acl_get_tag_type( entry, &currentTag );
447 if ( currentTag == type ) {
448 acl_delete_entry( newACL, entry );
449 // we have to start from the beginning, the iterator is
450 // invalidated, on deletion
451 ret = acl_get_entry( newACL, ACL_FIRST_ENTRY, &entry );
452 } else {
453 ret = acl_get_entry( newACL, ACL_NEXT_ENTRY, &entry );
454 }
455 }
456//printACL( newACL, "After cleaning out entries: " );
457
458 // now add the entries from the list
459 TQValueList< TQPair<TQString, unsigned short> >::const_iterator it = list.constBegin();
460 while ( it != list.constEnd() ) {
461 acl_create_entry( &newACL, &entry );
462 acl_set_tag_type( entry, type );
463 int id = type == ACL_USER? getUidForName( (*it).first):getGidForName( (*it).first );
464 if ( id == -1 || acl_set_qualifier( entry, &id ) != 0 ) {
465 // user or group doesn't exist => error
466 acl_delete_entry( newACL, entry );
467 allIsWell = false;
468 break;
469 } else {
470 permissionsToEntry( entry, (*it).second );
471 atLeastOneUserOrGroup = true;
472 }
473 ++it;
474 }
475//printACL( newACL, "After adding entries: " );
476 if ( allIsWell && atLeastOneUserOrGroup ) {
477 // 23.1.1 of 1003.1e states that as soon as there is a named user or
478 // named group entry, there needs to be a mask entry as well, so add
479 // one, if the user hasn't explicitely set one.
480 if ( entryForTag( newACL, ACL_MASK ) == 0 ) {
481 acl_calc_mask( &newACL );
482 }
483 }
484 if ( allIsWell && ( acl_valid( newACL ) == 0 ) ) {
485 acl_free( m_acl );
486 m_acl = newACL;
487 } else {
488 acl_free( newACL );
489 }
490 return allIsWell;
491}
492#endif
493
494bool KACL::setAllUserPermissions( const ACLUserPermissionsList &users )
495{
496#ifdef USE_POSIX_ACL
497 return d->setAllUsersOrGroups( users, ACL_USER );
498#else
499 Q_UNUSED( users );
500 return true;
501#endif
502}
503
504
505/**************************
506 * Deal with named groups *
507 **************************/
508
509unsigned short KACL::namedGroupPermissions( const TQString& name, bool *exists ) const
510{
511 *exists = false;
512#ifdef USE_POSIX_ACL
513 acl_entry_t entry;
514 gid_t id;
515 int ret = acl_get_entry( d->m_acl, ACL_FIRST_ENTRY, &entry );
516 while ( ret == 1 ) {
517 acl_tag_t currentTag;
518 acl_get_tag_type( entry, &currentTag );
519 if ( currentTag == ACL_GROUP ) {
520 id = *( (gid_t*) acl_get_qualifier( entry ) );
521 if ( d->getGroupName( id ) == name ) {
522 *exists = true;
523 return entryToPermissions( entry );
524 }
525 }
526 ret = acl_get_entry( d->m_acl, ACL_NEXT_ENTRY, &entry );
527 }
528#else
529 Q_UNUSED( name );
530#endif
531 return 0;
532}
533
534bool KACL::setNamedGroupPermissions( const TQString& name, unsigned short permissions )
535{
536#ifdef USE_POSIX_ACL
537 return d->setNamedUserOrGroupPermissions( name, permissions, ACL_GROUP );
538#else
539 Q_UNUSED( name );
540 Q_UNUSED( permissions );
541 return true;
542#endif
543}
544
545
546ACLGroupPermissionsList KACL::allGroupPermissions() const
547{
548 ACLGroupPermissionsList list;
549#ifdef USE_POSIX_ACL
550 acl_entry_t entry;
551 gid_t id;
552 int ret = acl_get_entry( d->m_acl, ACL_FIRST_ENTRY, &entry );
553 while ( ret == 1 ) {
554 acl_tag_t currentTag;
555 acl_get_tag_type( entry, &currentTag );
556 if ( currentTag == ACL_GROUP ) {
557 id = *( (gid_t*) acl_get_qualifier( entry ) );
558 TQString name = d->getGroupName( id );
559 unsigned short permissions = entryToPermissions( entry );
560 ACLGroupPermissions pair = qMakePair( name, permissions );
561 list.append( pair );
562 }
563 ret = acl_get_entry( d->m_acl, ACL_NEXT_ENTRY, &entry );
564 }
565#endif
566 return list;
567}
568
569bool KACL::setAllGroupPermissions( const ACLGroupPermissionsList &groups )
570{
571#ifdef USE_POSIX_ACL
572 return d->setAllUsersOrGroups( groups, ACL_GROUP );
573#else
574 Q_UNUSED( groups );
575 return true;
576#endif
577}
578
579/**************************
580 * from and to string *
581 **************************/
582
583bool KACL::setACL( const TQString &aclStr )
584{
585 bool ret = false;
586#ifdef USE_POSIX_ACL
587 if ( aclStr.isEmpty() )
588 return false;
589
590 acl_t temp = acl_from_text( aclStr.latin1() );
591 if ( acl_valid( temp ) != 0 ) {
592 // TODO errno is set, what to do with it here?
593 acl_free( temp );
594 } else {
595 if ( d->m_acl )
596 acl_free( d->m_acl );
597 d->m_acl = temp;
598 ret = true;
599 }
600#else
601 Q_UNUSED( aclStr );
602#endif
603 return ret;
604}
605
606TQString KACL::asString() const
607{
608#ifdef USE_POSIX_ACL
609 return aclAsString( d->m_acl );
610#else
611 return TQString::null;
612#endif
613}
614
615
616// helpers
617
618#ifdef USE_POSIX_ACL
619TQString KACL::KACLPrivate::getUserName( uid_t uid ) const
620{
621 TQString *temp;
622 temp = m_usercache.find( uid );
623 if ( !temp ) {
624 struct passwd *user = getpwuid( uid );
625 if ( user ) {
626 m_usercache.insert( uid, new TQString(TQString::fromLatin1(user->pw_name)) );
627 return TQString::fromLatin1( user->pw_name );
628 }
629 else
630 return TQString::number( uid );
631 }
632 else
633 return *temp;
634}
635
636
637TQString KACL::KACLPrivate::getGroupName( gid_t gid ) const
638{
639 TQString *temp;
640 temp = m_groupcache.find( gid );
641 if ( !temp ) {
642 struct group *grp = getgrgid( gid );
643 if ( grp ) {
644 m_groupcache.insert( gid, new TQString(TQString::fromLatin1(grp->gr_name)) );
645 return TQString::fromLatin1( grp->gr_name );
646 }
647 else
648 return TQString::number( gid );
649 }
650 else
651 return *temp;
652}
653
654static TQString aclAsString(const acl_t acl)
655{
656 char *aclString = acl_to_text( acl, 0 );
657 TQString ret = TQString::fromLatin1( aclString );
658 acl_free( (void*)aclString );
659 return ret;
660}
661
662
663#endif
664
665void KACL::virtual_hook( int, void* )
666{ /*BASE::virtual_hook( id, data );*/ }
667
668TQDataStream & operator<< ( TQDataStream & s, const KACL & a )
669{
670 s << a.asString();
671 return s;
672}
673
674TQDataStream & operator>> ( TQDataStream & s, KACL & a )
675{
676 TQString str;
677 s >> str;
678 a.setACL( str );
679 return s;
680}
KACL
The KCAL class encapsulates a POSIX Access Control List.
Definition: kacl.h:43
KACL::setNamedGroupPermissions
bool setNamedGroupPermissions(const TQString &name, unsigned short)
Set the permissions for a group with the name name.
Definition: kacl.cpp:534
KACL::KACL
KACL()
Creates an empty KACL.
Definition: kacl.cpp:94
KACL::maskPermissions
unsigned short maskPermissions(bool &exists) const
Return the entry for the permissions mask if there is one and sets exists to true.
Definition: kacl.cpp:274
KACL::asString
TQString asString() const
Return a string representation of the ACL.
Definition: kacl.cpp:606
KACL::isExtended
bool isExtended() const
The interface to the extended ACL.
Definition: kacl.cpp:130
KACL::setOthersPermissions
bool setOthersPermissions(unsigned short)
Set the permissions entry for others.
Definition: kacl.cpp:247
KACL::setMaskPermissions
bool setMaskPermissions(unsigned short)
Set the permissions mask for the ACL.
Definition: kacl.cpp:302
KACL::namedUserPermissions
unsigned short namedUserPermissions(const TQString &name, bool *exists) const
Access to the permissions entry for a named user, if such an entry exists.
Definition: kacl.cpp:315
KACL::basePermissions
mode_t basePermissions() const
Definition: kacl.cpp:257
KACL::isValid
bool isValid() const
Returns whether the KACL object represents a valid acl.
Definition: kacl.cpp:119
KACL::setOwningGroupPermissions
bool setOwningGroupPermissions(unsigned short)
Set the owning group's permissions entry.
Definition: kacl.cpp:228
KACL::allGroupPermissions
ACLGroupPermissionsList allGroupPermissions() const
Returns the list of all group permission entries.
Definition: kacl.cpp:546
KACL::setOwnerPermissions
bool setOwnerPermissions(unsigned short)
Set the owner's permissions entry.
Definition: kacl.cpp:209
KACL::setACL
bool setACL(const TQString &aclStr)
Sets the whole list from a string.
Definition: kacl.cpp:583
KACL::namedGroupPermissions
unsigned short namedGroupPermissions(const TQString &name, bool *exists) const
Access to the permissions entry for a named group, if such an entry exists.
Definition: kacl.cpp:509
KACL::othersPermissions
unsigned short othersPermissions() const
Definition: kacl.cpp:238
KACL::setAllUserPermissions
bool setAllUserPermissions(const ACLUserPermissionsList &list)
Replace the list of all user permissions with list.
Definition: kacl.cpp:494
KACL::allUserPermissions
ACLUserPermissionsList allUserPermissions() const
Returns the list of all group permission entries.
Definition: kacl.cpp:408
KACL::setNamedUserPermissions
bool setNamedUserPermissions(const TQString &name, unsigned short)
Set the permissions for a user with the name name.
Definition: kacl.cpp:397
KACL::setAllGroupPermissions
bool setAllGroupPermissions(const ACLGroupPermissionsList &)
Replace the list of all user permissions with list.
Definition: kacl.cpp:569
KACL::ownerPermissions
unsigned short ownerPermissions() const
The standard (non-extended) part of an ACL.
Definition: kacl.cpp:200
KACL::owningGroupPermissions
unsigned short owningGroupPermissions() const
Definition: kacl.cpp:219

tdeio/tdeio

Skip menu "tdeio/tdeio"
  • Main Page
  • Modules
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

tdeio/tdeio

Skip menu "tdeio/tdeio"
  • arts
  • dcop
  • dnssd
  • interfaces
  •   kspeech
  •     interface
  •     library
  •   tdetexteditor
  • kate
  • kded
  • kdoctools
  • kimgio
  • kjs
  • libtdemid
  • libtdescreensaver
  • tdeabc
  • tdecmshell
  • tdecore
  • tdefx
  • tdehtml
  • tdeinit
  • tdeio
  •   bookmarks
  •   httpfilter
  •   kpasswdserver
  •   kssl
  •   tdefile
  •   tdeio
  •   tdeioexec
  • tdeioslave
  •   http
  • tdemdi
  •   tdemdi
  • tdenewstuff
  • tdeparts
  • tdeprint
  • tderandr
  • tderesources
  • tdespell2
  • tdesu
  • tdeui
  • tdeunittest
  • tdeutils
  • tdewallet
Generated for tdeio/tdeio by doxygen 1.9.4
This website is maintained by Timothy Pearson.