| # kdecore Library API Documentation
Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Namespaces | Source Files

# kuser.cpp

    00001 /*
    00002  *  KUser - represent a user/account
    00003  *  Copyright (C) 2002 Tim Jansen <tim@tjansen.de>
    00004  *
    00005  *
    00006  *  This library is free software; you can redistribute it and/or
    00007  *  modify it under the terms of the GNU Library General Public
    00008  *  License as published by the Free Software Foundation; either
    00009  *  version 2 of the License, or (at your option) any later version.
    00010  *
    00011  *  This library is distributed in the hope that it will be useful,
    00012  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    00013  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00014  *  Library General Public License for more details.
    00015  *
    00016  *  You should have received a copy of the GNU Library General Public License
    00017  *  along with this library; see the file COPYING.LIB.  If not, write to
    00018  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    00019  *  Boston, MA 02111-1307, USA.
    00020  */
    00021
    00022 #include <kuser.h>
    00023
    00024 #include "kstringhandler.h"
    00025 #include <qvaluelist.h>
    00026 #include <qstringlist.h>
    00027
    00028 #include <sys/types.h>
    00029 #include <pwd.h>
    00030 #include <unistd.h>
    00031 #include <stdlib.h>
    00032 #include <grp.h>
    00033
    00034
    00035 class KUserPrivate : public KShared
    00036 {
    00037 public:
    00038     bool valid;
    00039     long uid, gid;
    00040     QString loginName, fullName;
    00041     QString roomNumber, workPhone, homePhone;
    00042     QString homeDir, shell;
    00043
    00044     KUserPrivate() : valid(false) {}
    00045
    00046     KUserPrivate(long _uid,
    00047              long _gid,
    00048              const QString &_loginname,
    00049              const QString &_fullname,
    00050              const QString &_room,
    00051              const QString &_workPhone,
    00052              const QString &_homePhone,
    00053              const QString &_homedir,
    00054              const QString &_shell) :
    00055         valid(true),
    00056         uid(_uid),
    00057         gid(_gid),
    00058         loginName(_loginname),
    00059         fullName(_fullname),
    00060         roomNumber(_room),
    00061         workPhone(_workPhone),
    00062         homePhone(_homePhone),
    00063         homeDir(_homedir),
    00064         shell(_shell) {}
    00065 };
    00066
    00067
    00068 KUser::KUser(UIDMode mode) {
    00069     long _uid = ::getuid(), _euid;
    00070     if (mode == UseEffectiveUID && (_euid = ::geteuid()) != _uid )
    00071         fillPasswd( ::getpwuid( _euid ) );
    00072     else {
    00073         fillName( ::getenv( "LOGNAME" ) );
    00074         if (uid() != _uid) {
    00075             fillName( ::getenv( "USER" ) );
    00076             if (uid() != _uid)
    00077                 fillPasswd( ::getpwuid( _uid ) );
    00078         }
    00079     }
    00080 }
    00081
    00082 KUser::KUser(long uid) {
    00083     fillPasswd( ::getpwuid( uid ) );
    00084 }
    00085
    00086 KUser::KUser(const QString& name) {
    00087     fillName( name.local8Bit().data() );
    00088 }
    00089
    00090 KUser::KUser(const char *name) {
    00091     fillName( name );
    00092 }
    00093
    00094 KUser::KUser(struct passwd *p) {
    00095     fillPasswd(p);
    00096 }
    00097
    00098 KUser::KUser(const KUser & user)
    00099   : d(user.d)
    00100 {
    00101 }
    00102
    00103 KUser& KUser::operator =(const KUser& user)
    00104 {
    00105   d = user.d;
    00106   return *this;
    00107 }
    00108
    00109 bool KUser::operator ==(const KUser& user) const {
    00110     if (isValid() != user.isValid())
    00111     return false;
    00112     if (isValid())
    00113     return uid() == user.uid();
    00114     else
    00115     return true;
    00116 }
    00117
    00118 bool KUser::operator !=(const KUser& user) const {
    00119     return !operator ==(user);
    00120 }
    00121
    00122 void KUser::fillName(const char *name) {
    00123     fillPasswd(name ? ::getpwnam( name ) : 0);
    00124 }
    00125
    00126 void KUser::fillPasswd(struct passwd *p) {
    00127     if (p) {
    00128         QString gecos = KStringHandler::from8Bit(p->pw_gecos);
    00129         QStringList gecosList = QStringList::split(',', gecos, true);
    00130
    00131         d = new KUserPrivate(p->pw_uid,
    00132                      p->pw_gid,
    00133                      QString::fromLocal8Bit(p->pw_name),
    00134                      (gecosList.size() > 0) ? gecosList[0] : QString::null,
    00135                      (gecosList.size() > 1) ? gecosList[1] : QString::null,
    00136                      (gecosList.size() > 2) ? gecosList[2] : QString::null,
    00137                      (gecosList.size() > 3) ? gecosList[3] : QString::null,
    00138                      QString::fromLocal8Bit(p->pw_dir),
    00139                      QString::fromLocal8Bit(p->pw_shell));
    00140     }
    00141     else
    00142         d = new KUserPrivate();
    00143 }
    00144
    00145 bool KUser::isValid() const {
    00146     return d->valid;
    00147 }
    00148
    00149 long KUser::uid() const {
    00150     if (d->valid)
    00151         return d->uid;
    00152     else
    00153         return -1;
    00154 }
    00155
    00156 long KUser::gid() const {
    00157     if (d->valid)
    00158         return d->gid;
    00159     else
    00160         return -1;
    00161 }
    00162
    00163 bool KUser::isSuperUser() const {
    00164     return uid() == 0;
    00165 }
    00166
    00167 QString KUser::loginName() const {
    00168     if (d->valid)
    00169         return d->loginName;
    00170     else
    00171         return QString::null;
    00172 }
    00173
    00174 QString KUser::fullName() const {
    00175     if (d->valid)
    00176         return d->fullName;
    00177     else
    00178         return QString::null;
    00179 }
    00180
    00181 QString KUser::roomNumber() const {
    00182     if (d->valid)
    00183         return d->roomNumber;
    00184     else
    00185         return QString::null;
    00186 }
    00187
    00188 QString KUser::workPhone() const {
    00189     if (d->valid)
    00190         return d->workPhone;
    00191     else
    00192         return QString::null;
    00193 }
    00194
    00195 QString KUser::homePhone() const {
    00196     if (d->valid)
    00197         return d->homePhone;
    00198     else
    00199         return QString::null;
    00200 }
    00201
    00202 QString KUser::homeDir() const {
    00203     if (d->valid)
    00204         return d->homeDir;
    00205     else
    00206         return QString::null;
    00207 }
    00208
    00209 QString KUser::shell() const {
    00210     if (d->valid)
    00211         return d->shell;
    00212     else
    00213         return QString::null;
    00214 }
    00215
    00216 QValueList<KUserGroup> KUser::groups() const {
    00217   QValueList<KUserGroup> result;
    00218   QValueList<KUserGroup> allGroups = KUserGroup::allGroups();
    00219   QValueList<KUserGroup>::const_iterator it;
    00220   for ( it = allGroups.begin(); it != allGroups.end(); ++it ) {
    00221     QValueList<KUser> users = (*it).users();
    00222     if ( users.find( *this ) != users.end()) {
    00223        result.append(*it);
    00224     }
    00225   }
    00226   return result;
    00227 }
    00228
    00229 QStringList KUser::groupNames() const {
    00230   QStringList result;
    00231   QValueList<KUserGroup> allGroups = KUserGroup::allGroups();
    00232   QValueList<KUserGroup>::const_iterator it;
    00233   for ( it = allGroups.begin(); it != allGroups.end(); ++it ) {
    00234     QValueList<KUser> users = (*it).users();
    00235     if ( users.find( *this ) != users.end()) {
    00236        result.append((*it).name());
    00237     }
    00238   }
    00239   return result;
    00240 }
    00241
    00242
    00243 QValueList<KUser> KUser::allUsers() {
    00244   QValueList<KUser> result;
    00245
    00246   struct passwd* p;
    00247
    00248   while ((p = getpwent()))  {
    00249     result.append(KUser(p));
    00250   }
    00251
    00252   endpwent();
    00253
    00254   return result;
    00255 }
    00256
    00257 QStringList KUser::allUserNames() {
    00258   QStringList result;
    00259
    00260   struct passwd* p;
    00261
    00262   while ((p = getpwent()))  {
    00263     result.append(QString::fromLocal8Bit(p->pw_name));
    00264   }
    00265
    00266   endpwent();
    00267   return result;
    00268 }
    00269
    00270
    00271 KUser::~KUser() {
    00272 }
    00273
    00274 class KUserGroupPrivate : public KShared
    00275 {
    00276 public:
    00277   bool valid;
    00278   long gid;
    00279   QString name;
    00280   QValueList<KUser> users;
    00281
    00282   KUserGroupPrivate() : valid(false) {}
    00283
    00284   KUserGroupPrivate(long _gid,
    00285                 const QString & _name,
    00286                 const QValueList<KUser> & _users):
    00287     valid(true),
    00288     gid(_gid),
    00289     name(_name),
    00290     users(_users) {}
    00291 };
    00292
    00293 KUserGroup::KUserGroup(KUser::UIDMode mode) {
    00294   KUser user(mode);
    00295   fillGroup(getgrgid(user.gid()));
    00296 }
    00297
    00298 KUserGroup::KUserGroup(long gid) {
    00299   fillGroup(getgrgid(gid));
    00300 }
    00301
    00302 KUserGroup::KUserGroup(const QString& name) {
    00303   fillName(name.local8Bit().data());
    00304 }
    00305
    00306 KUserGroup::KUserGroup(const char *name) {
    00307   fillName(name);
    00308 }
    00309
    00310 KUserGroup::KUserGroup(struct group *g) {
    00311   fillGroup(g);
    00312 }
    00313
    00314
    00315 KUserGroup::KUserGroup(const KUserGroup & group)
    00316   : d(group.d)
    00317 {
    00318 }
    00319
    00320 KUserGroup& KUserGroup::operator =(const KUserGroup& group) {
    00321   d = group.d;
    00322   return *this;
    00323 }
    00324
    00325 bool KUserGroup::operator ==(const KUserGroup& group) const {
    00326   if (isValid() != group.isValid())
    00327     return false;
    00328   if (isValid())
    00329     return gid() == group.gid();
    00330   else
    00331     return true;
    00332 }
    00333
    00334 bool KUserGroup::operator !=(const KUserGroup& user) const {
    00335   return !operator ==(user);
    00336 }
    00337
    00338 void KUserGroup::fillName(const char *name) {
    00339   fillGroup(name ? ::getgrnam( name ) : 0);
    00340 }
    00341
    00342 void KUserGroup::fillGroup(struct group *p) {
    00343   if (!p) {
    00344     d = new KUserGroupPrivate();
    00345     return;
    00346   }
    00347
    00348   QString name = KStringHandler::from8Bit(p->gr_name);
    00349   QValueList<KUser> users;
    00350
    00351   char **user = p->gr_mem;
    00352   for ( ; *user; user++) {
    00353     KUser kUser(QString::fromLocal8Bit(*user));
    00354     users.append(kUser);
    00355   }
    00356
    00357   d = new KUserGroupPrivate(p->gr_gid,
    00358             QString::fromLocal8Bit(p->gr_name),
    00359             users);
    00360
    00361 }
    00362
    00363 bool KUserGroup::isValid() const {
    00364   return d->valid;
    00365 }
    00366
    00367 long KUserGroup::gid() const {
    00368   if (d->valid)
    00369     return d->gid;
    00370   else
    00371     return -1;
    00372 }
    00373
    00374 QString KUserGroup::name() const {
    00375   if (d->valid)
    00376     return d->name;
    00377   else
    00378     return QString::null;
    00379 }
    00380
    00381 const QValueList<KUser>& KUserGroup::users() const {
    00382   return d->users;
    00383 }
    00384
    00385 QStringList KUserGroup::userNames() const {
    00386   QStringList result;
    00387   QValueList<KUser>::const_iterator it;
    00388   for ( it = d->users.begin(); it != d->users.end(); ++it ) {
    00389     result.append((*it).loginName());
    00390   }
    00391   return result;
    00392 }
    00393
    00394
    00395
    00396 QValueList<KUserGroup> KUserGroup::allGroups() {
    00397   QValueList<KUserGroup> result;
    00398
    00399   struct group* g;
    00400   while ((g = getgrent()))  {
    00401      result.append(KUserGroup(g));
    00402   }
    00403
    00404   endgrent();
    00405
    00406   return result;
    00407 }
    00408
    00409 QStringList KUserGroup::allGroupNames() {
    00410   QStringList result;
    00411
    00412   struct group* g;
    00413   while ((g = getgrent()))  {
    00414      result.append(QString::fromLocal8Bit(g->gr_name));
    00415   }
    00416
    00417   endgrent();
    00418
    00419   return result;
    00420 }
    00421
    00422
    00423 KUserGroup::~KUserGroup() {
    00424 }
    00425

This file is part of the documentation for kdecore Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:18:12 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003