module EU

can_lockfile?() click to toggle source

static VALUE
eu_lockable_p(VALUE self)
{
#if defined(HAVE_LCKPWDF) ||defined(HAVE_ULCKPWDF)
  return Qtrue;
#else
  return Qfalse;
#endif
}

endXXent() click to toggle source

static VALUE
eu_endXXent(VALUE self)
{
  eu_endpwent(self);
  eu_endgrent(self);
  eu_endspent(self);
  eu_endsgent(self);
  return Qnil;
}

endgrent() click to toggle source

VALUE eu_endgrent(VALUE self)
{
#ifdef HAVE_ENDGRENT
  endgrent();
#endif
  return Qnil;
}

endpwent() click to toggle source

VALUE eu_endpwent(VALUE self)
{
#ifdef HAVE_ENDPWENT
  endpwent();
#endif
  return Qnil;
}

endsgent() click to toggle source

VALUE eu_endsgent(VALUE self)
{
#ifdef HAVE_ENDSGENT
  endsgent();
#endif
  return Qnil;
}

endspent() click to toggle source

VALUE eu_endspent(VALUE self)
{
#ifdef HAVE_ENDSPENT
  endspent();
#endif
  return Qnil;
}

fgetgrent(p1) click to toggle source

static VALUE
eu_fgetgrent(VALUE self, VALUE io)
{
  struct group *grp;

  ensure_file(io);
  if ( (grp = fgetgrent(RFILE_FPTR(io))) == NULL )
    return Qnil;

  return setup_group(grp);
}

fgetpwent(p1) click to toggle source

static VALUE
eu_fgetpwent(VALUE self, VALUE io)
{
  struct passwd *pwd;

  ensure_file(io);
  if ( (pwd = fgetpwent(RFILE_FPTR(io))) == NULL )
    return Qnil;

  return setup_passwd(pwd);
}

fgetsgent(p1) click to toggle source

static VALUE
eu_fgetsgent(VALUE self, VALUE io)
{
  struct sgrp *sgroup;

  ensure_file(io);
  if ( (sgroup = fgetsgent(RFILE_FPTR(io))) == NULL )
    return Qnil;

  return setup_gshadow(sgroup);
}

fgetspent(p1) click to toggle source

static VALUE
eu_fgetspent(VALUE self, VALUE io)
{
  struct spwd *spwd;

  ensure_file(io);
  if ( (spwd = fgetspent(RFILE_FPTR(io))) == NULL )
    return Qnil;

  return setup_shadow(spwd);
}

find_grp(p1) click to toggle source

VALUE eu_getgrp(VALUE self, VALUE v)
{
  struct group *strt;
  eu_setgrent(self);

  if (FIXNUM_P(v))
    strt = getgrgid(NUM2UIDT(v));
  else {
    SafeStringValue(v);
    strt = getgrnam(StringValuePtr(v));
  }

  if (!strt)
    return Qnil;
  return setup_group(strt);
}

find_pwd(p1) click to toggle source

endif

VALUE eu_getpwd(VALUE self, VALUE v)
{
  struct passwd *strt;
  eu_setpwent(self);

  if ( FIXNUM_P(v) )
    strt = getpwuid(NUM2UIDT(v));
  else {
    SafeStringValue(v);
    strt = getpwnam(StringValuePtr(v));
  }

  if (!strt)
    return Qnil;

  return setup_passwd(strt);
}

find_sgrp(p1) click to toggle source

VALUE eu_getsgrp(VALUE self, VALUE v)
{
#ifdef GSHADOW
  struct sgrp *strt;
  eu_setsgent(self);

  if ( FIXNUM_P(v) ) {
    struct group *s;
    if ( (s = getgrgid(NUM2UIDT(v))) )
      v = setup_safe_str(s->gr_name);
  }

  SafeStringValue(v);
  strt = getsgnam(StringValuePtr(v));

  if (!strt)
    return Qnil;

  return setup_gshadow(strt);
#else
  return Qnil;
#endif
}

find_spwd(p1) click to toggle source

VALUE eu_getspwd(VALUE self, VALUE v)
{
#ifdef SHADOW
  struct spwd *strt;
  eu_setspent(self);

  if ( FIXNUM_P(v) ) {
    struct passwd *s;
    if ( (s = getpwuid(NUM2UIDT(v))) )
      v = rb_str_new2(s->pw_name);
    else
      return Qnil;
  }

  SafeStringValue(v);
  strt = getspnam(StringValuePtr(v));

  if (!strt)
    return Qnil;

  return setup_shadow(strt);
#else
  return Qnil;
#endif
}

getgrent() click to toggle source

VALUE eu_getgrent(VALUE self)
{
  struct group *grp;

  if (rb_block_given_p())
    each_group();
  else if ( (grp = getgrent()) )
    return setup_group(grp);
  return Qnil;
}

getgrnam(p1) click to toggle source

VALUE eu_getgrp(VALUE self, VALUE v)
{
  struct group *strt;
  eu_setgrent(self);

  if (FIXNUM_P(v))
    strt = getgrgid(NUM2UIDT(v));
  else {
    SafeStringValue(v);
    strt = getgrnam(StringValuePtr(v));
  }

  if (!strt)
    return Qnil;
  return setup_group(strt);
}

getlogin() click to toggle source

static VALUE
eu_getlogin(VALUE self)
{
  struct passwd *pwd;

  pwd = getpwuid(geteuid());
  return setup_passwd(pwd);
}

getpwent() click to toggle source

VALUE eu_getpwent(VALUE self)
{
  struct passwd *pwd;

  if (rb_block_given_p())
    each_passwd();
  else if ( (pwd = getpwent()) )
    return setup_passwd(pwd);
  return Qnil;
}

getpwnam(p1) click to toggle source

endif

VALUE eu_getpwd(VALUE self, VALUE v)
{
  struct passwd *strt;
  eu_setpwent(self);

  if ( FIXNUM_P(v) )
    strt = getpwuid(NUM2UIDT(v));
  else {
    SafeStringValue(v);
    strt = getpwnam(StringValuePtr(v));
  }

  if (!strt)
    return Qnil;

  return setup_passwd(strt);
}

getsgent() click to toggle source

VALUE eu_getsgent(VALUE self)
{
  struct sgrp *sgroup;

  if (rb_block_given_p())
    each_sgrp();
  else if ( (sgroup = getsgent()) )
    return setup_gshadow(sgroup);
  return Qnil;
}

getsgnam(p1) click to toggle source

VALUE eu_getsgrp(VALUE self, VALUE v)
{
#ifdef GSHADOW
  struct sgrp *strt;
  eu_setsgent(self);

  if ( FIXNUM_P(v) ) {
    struct group *s;
    if ( (s = getgrgid(NUM2UIDT(v))) )
      v = setup_safe_str(s->gr_name);
  }

  SafeStringValue(v);
  strt = getsgnam(StringValuePtr(v));

  if (!strt)
    return Qnil;

  return setup_gshadow(strt);
#else
  return Qnil;
#endif
}

getspent() click to toggle source

VALUE eu_getspent(VALUE self)
{
  struct spwd *shadow;

  if (rb_block_given_p())
    each_shadow();
  else if ( (shadow = getspent()) )
    return setup_shadow(shadow);
  return Qnil;
}

getspnam(p1) click to toggle source

VALUE eu_getspwd(VALUE self, VALUE v)
{
#ifdef SHADOW
  struct spwd *strt;
  eu_setspent(self);

  if ( FIXNUM_P(v) ) {
    struct passwd *s;
    if ( (s = getpwuid(NUM2UIDT(v))) )
      v = rb_str_new2(s->pw_name);
    else
      return Qnil;
  }

  SafeStringValue(v);
  strt = getspnam(StringValuePtr(v));

  if (!strt)
    return Qnil;

  return setup_shadow(strt);
#else
  return Qnil;
#endif
}

has_group?() click to toggle source

static VALUE
eu_group_p(VALUE self)
{
#ifdef GROUP
  return Qtrue;
#else
  return Qfalse;
#endif
}

has_gshadow?() click to toggle source

static VALUE
eu_gshadow_p(VALUE self)
{
#ifdef GSHADOW
  return Qtrue;
#else
  return Qfalse;
#endif
}

has_passwd?() click to toggle source

static VALUE
eu_passwd_p(VALUE self)
{
#ifdef PASSWD
  return Qtrue;
#else
  return Qfalse;
#endif
}

has_shadow?() click to toggle source

static VALUE
eu_shadow_p(VALUE self)
{
#ifdef SHADOW
  return Qtrue;
#else
  return Qfalse;
#endif
}

lckpwdf() click to toggle source

static VALUE
eu_lckpwdf(VALUE self)
{
  VALUE r;
  if ( !(r = eu_locked_p(self)) ) {
    if ( !(lckpwdf()) )
      r = Qtrue;
  }
  return r;
}

lock() click to toggle source

static VALUE
eu_lock(VALUE self)
{
  if (eu_lckpwdf(self)) {
    if (rb_block_given_p()) {
      if (in_lock)
        rb_raise(rb_eRuntimeError, "parallel lock iteration");
      rb_ensure(rb_yield, Qnil, lock_ensure, 0);
      return Qnil;
    }
    return Qtrue;
  } else
    rb_raise(rb_eIOError, "unable to create file lock");
}

locked?() click to toggle source

static VALUE
eu_locked_p(VALUE self)
{
  int i;
  errno = 0;
  i = lckpwdf();
  if (errno)
    rb_raise(rb_eSystemCallError, "Error locking passwd files: %s", strerror(errno));

  if (i)
    return Qtrue;
  else if (!ulckpwdf())
    return Qfalse;
  else
    rb_raise(rb_eIOError,"Unable to determine the locked state of password files");
}

me() click to toggle source

static VALUE
eu_getlogin(VALUE self)
{
  struct passwd *pwd;

  pwd = getpwuid(geteuid());
  return setup_passwd(pwd);
}

next_gid(p1 = v1) click to toggle source

VALUE next_gid(int argc, VALUE *argv, VALUE self)
{
  VALUE i;
  gid_t req;

  rb_scan_args(argc, argv, "01", &i);
  if (NIL_P(i))
    i = gid_global;

  i   = rb_Integer(i);
  req = NUM2UINT(i);

  if ( req > ((unsigned int)65533) )
    rb_raise(rb_eArgError, "GID must be between 0 and 65533");

  while ( getgrgid(req) || rb_ary_includes(assigned_gids, UINT2NUM(req)) ) req++;
  if (!argc)
    rb_ary_push(assigned_gids, UINT2NUM(req));
  else
    gid_global = UINT2NUM(req);

  return UINT2NUM(req);
}

next_gid=(p1 = v1) click to toggle source

VALUE next_gid(int argc, VALUE *argv, VALUE self)
{
  VALUE i;
  gid_t req;

  rb_scan_args(argc, argv, "01", &i);
  if (NIL_P(i))
    i = gid_global;

  i   = rb_Integer(i);
  req = NUM2UINT(i);

  if ( req > ((unsigned int)65533) )
    rb_raise(rb_eArgError, "GID must be between 0 and 65533");

  while ( getgrgid(req) || rb_ary_includes(assigned_gids, UINT2NUM(req)) ) req++;
  if (!argc)
    rb_ary_push(assigned_gids, UINT2NUM(req));
  else
    gid_global = UINT2NUM(req);

  return UINT2NUM(req);
}

next_uid(p1 = v1) click to toggle source

Start of helper functions

VALUE next_uid(int argc, VALUE *argv, VALUE self)
{
  VALUE i;
  uid_t req;

  rb_scan_args(argc, argv, "01", &i);
  if (NIL_P(i))
    i = uid_global;

  i   = rb_Integer(i);
  req = NUM2UINT(i);

  if ( req > ((unsigned int)65533) )
    rb_raise(rb_eArgError, "UID must be between 0 and 65533");

  while ( getpwuid(req) || rb_ary_includes(assigned_uids, UINT2NUM(req)) ) req++;
  if (!argc)
    rb_ary_push(assigned_uids, UINT2NUM(req));
  else
    uid_global = UINT2NUM(req);

  return UINT2NUM(req);
}

next_uid=(p1 = v1) click to toggle source

Start of helper functions

VALUE next_uid(int argc, VALUE *argv, VALUE self)
{
  VALUE i;
  uid_t req;

  rb_scan_args(argc, argv, "01", &i);
  if (NIL_P(i))
    i = uid_global;

  i   = rb_Integer(i);
  req = NUM2UINT(i);

  if ( req > ((unsigned int)65533) )
    rb_raise(rb_eArgError, "UID must be between 0 and 65533");

  while ( getpwuid(req) || rb_ary_includes(assigned_uids, UINT2NUM(req)) ) req++;
  if (!argc)
    rb_ary_push(assigned_uids, UINT2NUM(req));
  else
    uid_global = UINT2NUM(req);

  return UINT2NUM(req);
}

putgrent(p1, p2) click to toggle source

static VALUE
eu_putgrent(VALUE mod, VALUE entry, VALUE io)
{
  return group_putgrent(entry,io);
}

putpwent(p1, p2) click to toggle source

static VALUE
eu_putpwent(VALUE mod, VALUE entry, VALUE io)
{
  return user_putpwent(entry,io);
}

putsgent(p1, p2) click to toggle source

static VALUE
eu_putsgent(VALUE mod, VALUE entry, VALUE io)
{
  return group_putsgent(entry,io);
}

putspent(p1, p2) click to toggle source

static VALUE
eu_putspent(VALUE mod, VALUE entry, VALUE io)
{
  return user_putspent(entry,io);
}

read_group?() click to toggle source

static VALUE
eu_read_group_p(VALUE self)
{
  if (eu_group_p(self))
    return eu_file_readable_p(GROUP);
  return Qfalse;
}

read_gshadow?() click to toggle source

static VALUE
eu_read_gshadow_p(VALUE self)
{
#ifdef GSHADOW
  if (eu_gshadow_p(self) && eu_file_readable_p(GSHADOW))
    if (getsgent()) {
      setsgent();
      return Qtrue;
    }
#endif
  return Qfalse;
}

read_passwd?() click to toggle source

static VALUE
eu_read_passwd_p(VALUE self)
{
  if (eu_passwd_p(self))
    return eu_file_readable_p(PASSWD);
  return Qfalse;
}

read_shadow?() click to toggle source

static VALUE
eu_read_shadow_p(VALUE self)
{
#ifdef SHADOW
  if (eu_shadow_p(self))
    return eu_file_readable_p(SHADOW);
#endif
  return Qfalse;
}

setXXent() click to toggle source

static VALUE
eu_setXXent(VALUE self)
{
  eu_setpwent(self);
  eu_setgrent(self);
  eu_setspent(self);
  eu_setsgent(self);
  return Qnil;
}

setgrent() click to toggle source

VALUE eu_setgrent(VALUE self)
{
#ifdef HAVE_SETGRENT
  setgrent();
#endif
  return Qnil;
}

setpwent() click to toggle source

set/end syscalls

VALUE eu_setpwent(VALUE self)
{
#ifdef HAVE_SETPWENT
  setpwent();
#endif
  return Qnil;
}

setsgent() click to toggle source

VALUE eu_setsgent(VALUE self)
{
#ifdef HAVE_SETSGENT
  setsgent();
#endif
  return Qnil;
}

setspent() click to toggle source

VALUE eu_setspent(VALUE self)
{
#ifdef HAVE_SETSPENT
  setspent();
#endif
  return Qnil;
}

sgetgrent(p1) click to toggle source

members
VALUE eu_sgetgrent(VALUE self, VALUE str)
{
  VALUE ary;

  eu_setpwent(self);
  eu_setgrent(self);

  ary = rb_str_split(str, ":");
  str = rb_ary_entry(ary,0);

  if (RSTRING_BLANK_P(str))
    rb_raise(rb_eArgError,"Group name must be present.");

  if (getgrnam( StringValuePtr(str) ))
    return eu_grp_cur(str, ary);
  else
    return eu_grp_new(self, ary);
}

sgetpwent(p1) click to toggle source

INPUT Examples:

CURRENT USERS
bin:x:2:2:bin:/bin:/bin/bash
bin:x:::bin:/bin:/bin/bash
bin:x:::bin:/bin:/bin/sh
bin:x:::bin:/bin:/bin/sh
bin:x:::Bin User:/bin:/bin/sh
NEW USERS
- newuser:x:1000:1000:New User:/home/newuser:/bin/bash
- newuser:x:::New User:/home/newuser:/bin/bash
- newuser:x:::New User::/bin/bash

UNIVERSAL BEHAVIOR

if USERNAME empty
   - raise error

CURRENT USER

iff one of uid/gid is empty
   - if VAL is NOT equal to VAL in PASSWD
      - if VAL is available
          -  Populate VAL
      - else raise error
   - else Populate VAL
if PASSWORD, UID, GID, GECOS, HOMEDIR, SHELL are empty
   - populate VALUE from PASSWD

NEW USER

if UID/GID are empty
  - next_uid/next_gid
else
  - Test VALUE availability
then
  - Populate UID/GID
if GECOS, HOMEDIR, SHELL is empty
  - GECOS defaults to USERNAME
  - Assign default VALUE (Need to set config VALUES)
if PASSWORD is empty
   - raise Error

VALUE eu_sgetpwent(VALUE self, VALUE str)
{
  VALUE ary;

  eu_setpwent(self);
  eu_setgrent(self);

  ary = rb_str_split(str, ":");
  str = rb_ary_entry(ary,0);

  if (RSTRING_BLANK_P(str))
    rb_raise(rb_eArgError,"User name must be present.");

  if (getpwnam( StringValuePtr(str) ))
    return eu_parsecurrent(str, ary);
  else
    return eu_parsenew(self, ary);
}

sgetsgent(p1) click to toggle source

VALUE eu_sgetsgent(VALUE self, VALUE nam)
{
#ifdef GSHADOW
  struct sgrp *gshadow;

  SafeStringValue(nam);
  if ( !(gshadow = sgetsgent(StringValuePtr(nam))) )
    rb_raise(rb_eArgError,
             "can't parse %s into EtcUtils::GShadow", StringValuePtr(nam));

  return setup_gshadow(gshadow);
#else
  return Qnil;
#endif
}

sgetspent(p1) click to toggle source

VALUE eu_sgetspent(VALUE self, VALUE nam)
{
#ifdef SHADOW
  struct spwd *shadow;

  SafeStringValue(nam);
  if ( !(shadow = sgetspent(StringValuePtr(nam))) )
    rb_raise(rb_eArgError,
             "can't parse %s into EtcUtils::Shadow", StringValuePtr(nam));

  return setup_shadow(shadow);
#else
  return Qnil;
#endif
}

ulckpwdf() click to toggle source

static VALUE
eu_ulckpwdf(VALUE self)
{
  VALUE r;
  if ( (r = eu_locked_p(self)) )
    if ( !(ulckpwdf()) )
      r = Qtrue;
  return r;
}

unlock() click to toggle source

static VALUE
eu_unlock(VALUE self)
{
  return eu_ulckpwdf(self);
}

Constants

Public Class Methods