• 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
44 static void printACL( acl_t acl, const TQString &comment );
45 static TQString aclAsString(const acl_t acl);
46 #endif
47 
48 class KACL::KACLPrivate {
49 public:
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< QPair<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 
76 KACL::KACL( const TQString &aclString )
77  : d( new KACLPrivate )
78 {
79  setACL( aclString );
80 }
81 
82 KACL::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 
94 KACL::KACL()
95  : d( new KACLPrivate )
96 {
97 }
98 
99 KACL::KACL( const KACL& rhs )
100  : d( new KACLPrivate )
101 {
102  setACL( rhs.asString() );
103 }
104 
105 KACL::~KACL()
106 {
107  delete d;
108 }
109 
110 bool 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 
119 bool 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 
130 bool 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
140 static 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 
154 static 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 
164 static 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 
175 static void printACL( acl_t acl, const TQString &comment )
176 {
177  kdDebug() << comment << aclAsString( acl ) << endl;
178 }
179 
180 static 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 
189 static 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 
200 unsigned 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 
209 bool 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 
219 unsigned 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 
228 bool 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 
238 unsigned 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 
247 bool 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 
257 mode_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 
274 unsigned 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
290 bool 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 
302 bool 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  **************************/
315 unsigned 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
342 bool 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 
397 bool 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 
408 ACLUserPermissionsList 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
432 bool KACL::KACLPrivate::setAllUsersOrGroups( const TQValueList< QPair<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< QPair<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 
494 bool 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 
509 unsigned 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 
534 bool 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 
546 ACLGroupPermissionsList 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 
569 bool 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 
583 bool 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 
606 TQString 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
619 TQString 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 
637 TQString 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 
654 static 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 
665 void KACL::virtual_hook( int, void* )
666 { /*BASE::virtual_hook( id, data );*/ }
667 
668 TQDataStream & operator<< ( TQDataStream & s, const KACL & a )
669 {
670  s << a.asString();
671  return s;
672 }
673 
674 TQDataStream & operator>> ( TQDataStream & s, KACL & a )
675 {
676  TQString str;
677  s >> str;
678  a.setACL( str );
679  return s;
680 }
KACL::basePermissions
mode_t basePermissions() const
Definition: kacl.cpp:257
KACL::setACL
bool setACL(const TQString &aclStr)
Sets the whole list from a string.
Definition: kacl.cpp:583
KACL::setOwnerPermissions
bool setOwnerPermissions(unsigned short)
Set the owner's permissions entry.
Definition: kacl.cpp:209
KACL::ownerPermissions
unsigned short ownerPermissions() const
The standard (non-extended) part of an ACL.
Definition: kacl.cpp:200
KACL::setNamedGroupPermissions
bool setNamedGroupPermissions(const TQString &name, unsigned short)
Set the permissions for a group with the name name.
Definition: kacl.cpp:534
KACL::setAllUserPermissions
bool setAllUserPermissions(const ACLUserPermissionsList &list)
Replace the list of all user permissions with list.
Definition: kacl.cpp:494
KACL::asString
TQString asString() const
Return a string representation of the ACL.
Definition: kacl.cpp:606
KACL::allGroupPermissions
ACLGroupPermissionsList allGroupPermissions() const
Returns the list of all group permission entries.
Definition: kacl.cpp:546
KACL::isValid
bool isValid() const
Returns whether the KACL object represents a valid acl.
Definition: kacl.cpp:119
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::KACL
KACL()
Creates an empty KACL.
Definition: kacl.cpp:94
KACL::isExtended
bool isExtended() const
The interface to the extended ACL.
Definition: kacl.cpp:130
KACL::owningGroupPermissions
unsigned short owningGroupPermissions() const
Definition: kacl.cpp:219
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::setNamedUserPermissions
bool setNamedUserPermissions(const TQString &name, unsigned short)
Set the permissions for a user with the name name.
Definition: kacl.cpp:397
KACL::setOthersPermissions
bool setOthersPermissions(unsigned short)
Set the permissions entry for others.
Definition: kacl.cpp:247
KACL
The KCAL class encapsulates a POSIX Access Control List.
Definition: kacl.h:42
KACL::othersPermissions
unsigned short othersPermissions() const
Definition: kacl.cpp:238
KACL::setMaskPermissions
bool setMaskPermissions(unsigned short)
Set the permissions mask for the ACL.
Definition: kacl.cpp:302
KACL::allUserPermissions
ACLUserPermissionsList allUserPermissions() const
Returns the list of all group permission entries.
Definition: kacl.cpp:408
KACL::setOwningGroupPermissions
bool setOwningGroupPermissions(unsigned short)
Set the owning group's permissions entry.
Definition: kacl.cpp:228
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::setAllGroupPermissions
bool setAllGroupPermissions(const ACLGroupPermissionsList &)
Replace the list of all user permissions with list.
Definition: kacl.cpp:569

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
  •     tdecore
  • tdeabc
  • tdecmshell
  • tdecore
  • tdefx
  • tdehtml
  • tdeinit
  • tdeio
  •   bookmarks
  •   httpfilter
  •   kpasswdserver
  •   kssl
  • tdeioslave
  •   http
  •   tdefile
  •   tdeio
  •   tdeioexec
  • tdemdi
  •   tdemdi
  • tdenewstuff
  • tdeparts
  • tdeprint
  • tderandr
  • tderesources
  • tdespell2
  • tdesu
  • tdeui
  • tdeunittest
  • tdeutils
  • tdewallet
Generated for tdeio/tdeio by doxygen 1.8.8
This website is maintained by Timothy Pearson.