Source Code (Use browser search to find items of interest.)

kuser'KUsers (./kdeadmin/kuser/kuser.h:159)

class KUsers {
public:
  KUsers();
  ~KUsers();
  KUser *lookup(const char *name);
  KUser *lookup(uid_t uid);
  uid_t first_free();

  bool load();

  bool save();

  KUser *first();
  KUser *next();
  uint count() const;
  KUser *operator[](uint num);

  void add(KUser *ku);
  void del(KUser *au);

protected:
  bool p_backuped;
  bool s_backuped;

  mode_t pwd_mode;
  mode_t sdw_mode;

  uid_t pwd_uid;
  gid_t pwd_gid;

  uid_t sdw_uid;
  gid_t sdw_gid;

  QList<KUser> u;
  QList<KUser> du;

  bool doCreate();
  bool doDelete();
  void fillGecos(KUser *user, const char *gecos);
  bool loadpwd();
  bool loadsdw();

  bool savepwd();
  bool savesdw();
};

kuser'KUsers::KUsers() (./kdeadmin/kuser/kuser.cpp:356)

KUsers::KUsers() {
  p_backuped = FALSE;
  s_backuped = FALSE;

  pwd_mode = 0644;
  pwd_uid = 0;
  pwd_gid = 0;

  sdw_mode = 0600;
  sdw_uid = 0;
  sdw_gid = 0;

  u.setAutoDelete(TRUE);
  du.setAutoDelete(TRUE);

  if (!load())
    err->display();
}

kuser'KUsers::fillGecos() (./kdeadmin/kuser/kuser.cpp:375)

void KUsers::fillGecos(KUser *user, const char *gecos) {
  int no = 0;
  const char *s = gecos;
  const char *pos = NULL;
  // At least one part of the string exists
  for(;;) {
    pos = strchr(s, ',');
    char val[200];
    if(pos == NULL)
      strcpy(val, s);
    else {
      strncpy(val, s, (int)(pos-s));
      val[(int)(pos-s)] = 0;
    }

    switch(no) {
      case 0: user->setFullName(val); break;
#ifdef __FreeBSD__
      case 1: user->setOffice(val); break;
      case 2: user->setWorkPhone(val); break;
      case 3: user->setHomePhone(val); break;
#else
      case 1: user->setOffice1(val); break;
      case 2: user->setOffice2(val); break;
      case 3: user->setAddress(val); break;
#endif
    }
    if(pos == NULL) break;
    s = pos+1;
    no++;
  }
}

kuser'KUsers::load() (./kdeadmin/kuser/kuser.cpp:408)

bool KUsers::load() {
  if (!loadpwd())
    return FALSE;

  if (!loadsdw())
    return FALSE;

  return TRUE;
}

// Load passwd file

kuser'KUsers::loadpwd() (./kdeadmin/kuser/kuser.cpp:420)

bool KUsers::loadpwd() {
  passwd *p;
  KUser *tmpKU = 0;

  // Start reading passwd file

  struct stat st;

  stat(PASSWORD_FILE, &st);
  pwd_mode = st.st_mode & 0666;
  pwd_uid = st.st_uid;
  pwd_gid = st.st_gid;

  // We are reading our PASSWORD_FILE
  QString tmp;
#ifdef HAVE_FGETPWENT
  FILE *fpwd = fopen(PASSWORD_FILE, "r");
  if(fpwd == NULL) {
     err->addMsg(i18n("Error opening %1 for reading").arg(PASSWORD_FILE));
     return FALSE;
  }

  while ((p = fgetpwent(fpwd)) != NULL) {
#else
  while ((p = getpwent()) != NULL) {
#endif
#ifdef _KU_QUOTA
    kug->getQuotas().addQuota(p->pw_uid);
#endif
    tmpKU = new KUser();
    tmpKU->setUID(p->pw_uid);
    tmpKU->setGID(p->pw_gid);
    tmpKU->setName(p->pw_name);
    tmpKU->setPwd(p->pw_passwd);
    tmpKU->setHomeDir(p->pw_dir);
    tmpKU->setShell(p->pw_shell);
#ifdef __FreeBSD__
    tmpKU->setClass(p->pw_class);
    tmpKU->setLastChange(p->pw_change);
    tmpKU->setExpire(p->pw_expire);
#endif

    if ((p->pw_gecos != 0) && (p->pw_gecos[0] != 0))
      fillGecos(tmpKU, p->pw_gecos);

    u.append(tmpKU);
  }

  // End reading passwd file

#ifdef HAVE_FGETPWENT
  fclose(fpwd);
#endif

  return (TRUE);
}

// Load shadow passwords

kuser'KUsers::loadsdw() (./kdeadmin/kuser/kuser.cpp:479)

bool KUsers::loadsdw() {
#ifdef _KU_SHADOW
  QString tmp;
  struct spwd *spw;
  KUser *up = NULL;
  FILE *f;

  struct stat st;

  if (!is_shadow)
    return TRUE;

  stat(SHADOW_FILE, &st);
  sdw_mode = st.st_mode & 0666;
  sdw_uid = st.st_uid;
  sdw_gid = st.st_gid;

  if ((f = fopen(SHADOW_FILE, "r")) == NULL) {
    is_shadow = 0;
    printf("Shadow file missing detected\n");
    return TRUE;
  }

  fclose(f);

  setspent();

  while ((spw = getspent())) {     // read a shadow password structure
    if ((up = lookup(spw->sp_namp)) == NULL) {
      err->addMsg(i18n("No /etc/passwd entry for %1.\nEntry will be removed at the next `Save'-operation.")
		  .arg(spw->sp_namp));
      err->display();
      continue;
    }

    up->setSPwd(spw->sp_pwdp);        // cp the encrypted pwd
    up->setLastChange(spw->sp_lstchg);
    up->setMin(spw->sp_min);
    up->setMax(spw->sp_max);
#ifndef _SCO_DS
    up->setWarn(spw->sp_warn);
    up->setInactive(spw->sp_inact);
    up->setExpire(spw->sp_expire);
    up->setFlag(spw->sp_flag);
#endif
  }

  endspent();
#endif // _KU_SHADOW
  return TRUE;
}

kuser'KUsers::save() (./kdeadmin/kuser/kuser.cpp:531)

bool KUsers::save() {
  if (!savepwd())
    return FALSE;

  if (!savesdw())
    return FALSE;

  if (!doDelete())
    return FALSE;

  if (!doCreate())
    return FALSE;

  return TRUE;
}

kuser'KUsers::doCreate() (./kdeadmin/kuser/kuser.cpp:547)

bool KUsers::doCreate() {
  for (unsigned int i=0; i<u.count(); i++) {
    KUser *user = u.at(i);

    if(user->getCreateMailBox()) {
      user->createMailBox();
      user->setCreateMailBox(0);
    }

    if(user->getCreateHome()) {
       user->createHome();
       user->setCreateHome(0);
    }

    if(user->getCopySkel()) {
       user->copySkel();
       user->setCopySkel(0);
    }
  }

  return TRUE;
}

kuser'KUsers::doDelete() (./kdeadmin/kuser/kuser.cpp:570)

bool KUsers::doDelete() {
  for (unsigned int i=0; i<du.count(); i++) {
    KUser *user = du.at(i);

    user->removeHome();
    user->removeCrontabs();
    user->removeMailBox();
    user->removeProcesses();

    du.remove(i);
  }

  return TRUE;
}

// Save password file

kuser'KUsers::savepwd() (./kdeadmin/kuser/kuser.cpp:587)

bool KUsers::savepwd() {
  FILE *passwd;
  QString s;
  QString s1;

  QString tmp;

  if (!p_backuped) {
    backup(PASSWORD_FILE);
    p_backuped = TRUE;
  }

  umask(0077);

  if ((passwd = fopen(PASSWORD_FILE,"w")) == NULL) {
    err->addMsg(i18n("Error opening %1 for writing").arg(PASSWORD_FILE));
    return FALSE;
  }

  for (unsigned int i=0; i<u.count(); i++) {
    KUser *user = u.at(i);

#ifdef __FreeBSD__
    s = QString("%1:%2:%3:%4:%5:%6:%7:")
        .arg(user->getName())
        .arg(user->getPwd())
	.arg(user->getUID())
        .arg(user->getGID())
	.arg(user->getClass())
        .arg(user->getLastChange())
	.arg(user->getExpire());

    s1 = QString("%1,%2,%3,%4")
         .arg(user->getFullName())
         .arg(user->getOffice())
         .arg(user->getWorkPhone())
         .arg(user->getHomePhone());
#else

    s = QString("%1:%2:%3:%4:")
        .arg(user->getName())
        .arg(user->getPwd())
	.arg(user->getUID())
        .arg(user->getGID());

    s1 = QString("%1,%2,%3,%4")
         .arg(user->getFullName())
	 .arg(user->getOffice1())
	 .arg(user->getOffice2())
	 .arg(user->getAddress());

#endif

    for (int j=(s1.length()-1); j>=0; j--) {
      if (s1[j] != ',')
        break;

      s1.truncate(j);
    }

    s += s1+":"+user->getHomeDir()+":"+user->getShell()+"\n";
    fputs((const char *)s, passwd);
  }
  fclose(passwd);

  chmod(PASSWORD_FILE, pwd_mode);
  chown(PASSWORD_FILE, pwd_uid, pwd_gid);

#ifdef PWMKDB
  // need to run a utility program to build /etc/passwd, /etc/pwd.db
  // and /etc/spwd.db from /etc/master.passwd
  if (system(PWMKDB) != 0) {
     err->addMsg(i18n("Unable to build password database"), STOP);
     return FALSE;
  }
#endif

  return TRUE;
}

// Save shadow passwords file

kuser'KUsers::savesdw() (./kdeadmin/kuser/kuser.cpp:669)

bool KUsers::savesdw() {
#ifdef _KU_SHADOW
  QString tmp;
  FILE *f;
  struct spwd *spwp;
  struct spwd s;
  KUser *up;

  if (!is_shadow)
    return TRUE;

  if (!s_backuped) {
    backup(SHADOW_FILE);
    s_backuped = TRUE;
  }

  umask(0077);

  if ((f = fopen(SHADOW_FILE, "w")) == NULL) {
    err->addMsg(i18n("Error opening %1 for writing").arg(SHADOW_FILE));
    return FALSE;
  }

  s.sp_namp = (char *)malloc(200);
  s.sp_pwdp = (char *)malloc(200);
    
  for (uint index = 0; index < u.count(); index++) {
    up = u.at(index);
    if (!(const char *)up->getSPwd()) {
      err->addMsg(i18n("No shadow entry for %1.").arg(up->getName()));
      continue;
    }

    strncpy(s.sp_namp, (const char *)up->getName(), 200);
    strncpy(s.sp_pwdp, (const char *)up->getSPwd(), 200);
    s.sp_lstchg = up->getLastChange();
    s.sp_min    = up->getMin();
    s.sp_max    = up->getMax();
#ifndef _SCO_DS
    s.sp_warn   = up->getWarn();
    s.sp_inact  = up->getInactive();
    s.sp_expire = up->getExpire();
    s.sp_flag   = up->getFlag();
#endif
    spwp = &s;
    putspent(spwp, f);
  }
  fclose(f);

  chmod(SHADOW_FILE, sdw_mode);
  chown(SHADOW_FILE, sdw_uid, sdw_gid);

  free(s.sp_namp);
  free(s.sp_pwdp);
#endif // _KU_SHADOW
  return TRUE;
}

kuser'KUsers::lookup() (./kdeadmin/kuser/kuser.cpp:727)

KUser *KUsers::lookup(const char *name) {
  for (uint i = 0; i<u.count(); i++)
    if (u.at(i)->getName() == name)
      return (u.at(i));
  return NULL;
}

kuser'KUsers::lookup() (./kdeadmin/kuser/kuser.cpp:734)

KUser *KUsers::lookup(uid_t uid) {
  for (uint i = 0; i<u.count(); i++)
    if (u.at(i)->getUID() == uid)
      return (u.at(i));
  return NULL;
}

kuser'KUsers::first_free() (./kdeadmin/kuser/kuser.cpp:741)

uid_t KUsers::first_free() {
  uid_t t = _KU_FIRST_UID ;

  for (t = _KU_FIRST_UID ; t<65534; t++)
    if (lookup(t) == NULL)
      return t;

  err->addMsg(i18n("You have more than 65534 users!?!? You have ran out of uid space!"));
  return (-1);
}

kuser'KUsers::~KUsers() (./kdeadmin/kuser/kuser.cpp:752)

KUsers::~KUsers() {
  u.clear();
  du.clear();
}

kuser'KUsers::count() (./kdeadmin/kuser/kuser.cpp:757)

uint KUsers::count() const {
  return u.count();
}

kuser'KUsers::first() (./kdeadmin/kuser/kuser.cpp:765)

KUser *KUsers::first() {
  return u.first();
}

kuser'KUsers::next() (./kdeadmin/kuser/kuser.cpp:769)

KUser *KUsers::next() {
  return u.next();
}

kuser'KUsers::add() (./kdeadmin/kuser/kuser.cpp:773)

void KUsers::add(KUser *ku) {
  u.append(ku);
}

kuser'KUsers::del() (./kdeadmin/kuser/kuser.cpp:777)

void KUsers::del(KUser *au) {
  KUser *nu = new KUser(au);
  du.append(nu);
  u.remove(au);
}