- same func for get and set

- (-65533) as an invalid number
- sanity checks

1 files changed, 353 insertions, 263 deletions

diff --git a/USER/USER.xs b/USER/USER.xs
index 756734a..50e32fb 100644
--- a/USER/USER.xs
+++ b/USER/USER.xs
@@ -64,102 +64,17 @@ Admin_DESTROY(self)
         safefree((char*)self);
 
 int
-Admin_UserAdd(self, is_system, dont_create_home, enthash)
+Admin_UserAdd(self, ent, is_system, dont_create_home)
         USER::ADMIN *self
+        USER::ENT *ent
         int is_system
         int dont_create_home
-        SV * enthash
-        PREINIT:
-        SV **ssv;
-        HV *hv;
-        if ( SvROK(enthash) && (SvTYPE(SvRV(enthash)) == SVt_PVHV) )
-                hv = (HV*)SvRV(enthash);
-        else{
-                warn("XS_UserAdd: enthash was not an HV ref");
-        }
         CODE:
-        USER__ENT *ent;
-        USER__ERR *error;
-        GValue *value, val;
+        USER__ERR *error = NULL;
         long uidNumber, gidNumber;
         char *skeleton = "/etc/skel", *homeDirectory = NULL;
-        GValueArray *values;
-        ent = lu_ent_new();
-        memset(&val, 0, sizeof(val));
-        g_value_init(&val, G_TYPE_STRING);
-        ssv = hv_fetch(hv, "username", 13, 0);
-        if( ssv != NULL ){
-                if( SvPOK( *ssv ) )
-                        lu_user_default(self, SvPV(*ssv,PL_na), is_system, ent);
-                else{
-                        warn("XS_UserAdd: Cannot add default ent");
-                        RETVAL = 0;  
-              }
-        }
-        else
-        warn("XS_UserAdd: hash elem username was null");
-        ssv = hv_fetch(hv, "gecos", 5, 0);
-        if( ssv != NULL ){
-                if( SvPOK( *ssv ) ) {
-                        g_value_set_string(&val, SvPV(*ssv,PL_na));
-                        lu_ent_clear(ent, LU_GECOS);
-                        lu_ent_add(ent, LU_GECOS, &val);
-                } else {
-                        warn("XS_UserAdd: Cannot add gecos to ent");
-                }
-        }
-        else
-                warn("XS_UserAdd: hash elem gecos was null");
-        ssv = hv_fetch(hv, "homedir", 7, 0);
-        if( ssv != NULL ){
-                if( SvPOK( *ssv ) ) {
-                        g_value_set_string(&val, SvPV(*ssv,PL_na));
-                        lu_ent_clear(ent, LU_HOMEDIRECTORY);
-                        lu_ent_add(ent, LU_HOMEDIRECTORY, &val);
-                } else{
-                        warn("XS_UserAdd: Cannot add Home Dir to ent");
-                }
-        }
-        else
-                warn("XS_UserAdd: hash elem homedir was null");
-        ssv = hv_fetch(hv, "loginshell", 10, 0);
-        if( ssv != NULL ){
-                if( SvPOK( *ssv ) ) {
-                        g_value_set_string(&val, SvPV(*ssv,PL_na));
-                        lu_ent_clear(ent, LU_LOGINSHELL);
-                        lu_ent_add(ent, LU_LOGINSHELL, &val);
-                } else {
-                        warn("XS_UserAdd: Cannot add Login Shell to ent");
-                }
-        }
-        else
-                warn("XS_UserAdd: hash elem loginshell was null");
-        g_value_unset(&val);
-        g_value_init(&val, G_TYPE_LONG);
-        ssv = hv_fetch( hv, "uid", 3, 0);
-        if( ssv != NULL ){
-                if( SvIOK( *ssv ) && *ssv != -1) {
-                        g_value_set_long(&val, (long)SvIV( *ssv ));
-                        lu_ent_clear(ent, LU_UIDNUMBER);
-                        lu_ent_add(ent, LU_UIDNUMBER, &val);
-                 } else {
-                        warn("XS_UserAdd: hash elem Uid was not IOK");
-                }
-        }
-        else
-                warn("XS_UserAdd: hash elem uid was null");
-        ssv = hv_fetch( hv, "gid", 3, 0);
-        if( ssv != NULL ){
-                if( SvIOK( *ssv ) && *ssv != -1) {
-                        g_value_set_long(&val, (long)SvIV( *ssv ));
-                        lu_ent_clear(ent, LU_GIDNUMBER);
-                        lu_ent_add(ent, LU_GIDNUMBER, &val);
-                } else {
-                        warn("XS_UserAdd: hash elem Uid was not IOK");
-                }
-        }
-        else
-                warn("XS_UserAdd: hash elem uid was null");
+        GValueArray *values; 
+        GValue *value;
         /* GMOT (Great Moment Of Truth) */
         if (lu_user_add(self, ent, &error) == FALSE) {
                 croak("Account creation failed: %s.\n", error ? error->string : "Unknown error");
@@ -204,19 +119,13 @@ Admin_UserAdd(self, is_system, dont_create_home, enthash)
 
                 /* Create a mail spool for the user. */
                 if (lu_mailspool_create_remove(self, ent, TRUE) != TRUE) {
-                        fprintf(stderr, _("Error creating mail spool.\n"));
+                        warn(_("Error creating mail spool.\n"));
                         return 8;
                 }
         }
         OUTPUT:
         RETVAL
 
-
-void 
-Admin_GroupAdd(self, enthash)
-        USER::ADMIN *self
-        SV* enthash
-
 void
 Admin_UserDel(self, ent)
         USER::ADMIN *self
@@ -228,6 +137,17 @@ Admin_UserEdit(self, ent)
         USER::ENT *ent
 
 void
+Admin_InitUser(self, name, is_system)
+        USER::ADMIN *self
+        char *name
+        int is_system
+        PPCODE:
+        USER__ENT *ent;
+        ent = lu_ent_new();
+        lu_user_default(self, name, is_system, ent);
+        XPUSHs(sv_2mortal(sv_bless(newRV_noinc(newSViv(ent)), gv_stashpv("USER::ENT", 1))));
+
+void
 Admin_LookupUserByName(self, name)
         USER::ADMIN *self
         char *name
@@ -283,6 +203,32 @@ Admin_LookupGroupById(self, id)
                 lu_ent_free(ent);
         }
 
+void 
+Admin_GroupAdd(self, name)
+        USER::ADMIN *self
+        char *name
+
+void
+Admin_GroupDel(self, ent)
+        USER::ADMIN *self
+        USER::ENT *ent
+
+void
+Admin_GroupEdit(self, ent)
+        USER::ADMIN *self
+        USER::ENT *ent
+
+void
+Admin_InitGroup(self, name, is_system)
+        USER::ADMIN *self
+        char *name
+        int is_system
+        PPCODE:
+        USER__ENT *ent;
+        ent = lu_ent_new();
+        lu_group_default(self, name, is_system, ent);
+        XPUSHs(sv_2mortal(sv_bless(newRV_noinc(newSViv(ent)), gv_stashpv("USER::ENT", 1))));
+
 AV *
 Admin_EnumerateUsersByGroup(self, name)
         USER::ADMIN *self
@@ -414,282 +360,426 @@ Ent_EntType(self)
         }
         
 void 
-Ent_UserName(self)
+Ent_UserName(self, ssv)
         USER::ENT *self
+        SV * ssv
         PPCODE:
         GValueArray *values;
-        GValue *value;
-        values = lu_ent_get(self, LU_USERNAME);
-        if (values != NULL) {
-                value = g_value_array_get_nth(values, 0);
-                if (G_VALUE_HOLDS_STRING(value)) {
-                        XPUSHs(sv_2mortal(newSVpv(g_value_get_string(value), 0)));
-                } else if (G_VALUE_HOLDS_LONG(value)) {
-                        XPUSHs(sv_2mortal(newSVpv(g_strdup_printf("%ld", g_value_get_long(value)), 0)));
+        GValue *value, val;
+        if ( SvIOK(ssv) && SvIV(ssv) == -65533) {
+                values = lu_ent_get(self, LU_USERNAME);
+                if (values != NULL) {
+                        value = g_value_array_get_nth(values, 0);
+                        if (G_VALUE_HOLDS_STRING(value)) {
+                                XPUSHs(sv_2mortal(newSVpv(g_value_get_string(value), 0)));
+                        } else if (G_VALUE_HOLDS_LONG(value)) {
+                                XPUSHs(sv_2mortal(newSVpv(g_strdup_printf("%ld", g_value_get_long(value)), 0)));
+                        }
                 }
+        } else if( SvPOK( ssv ) ) {
+                memset(&val, 0, sizeof(val));
+                g_value_init(&val, G_TYPE_STRING);
+                g_value_set_string(&val, SvPV(ssv,PL_na));
+                lu_ent_clear(self, LU_USERNAME);
+                lu_ent_add(self, LU_USERNAME, &val);
+        } else {
+                warn("XS_UserAdd: Cannot make operation on  LU_USERNAME attribute");
         }
 
 void 
-Ent_GroupName(self)
+Ent_GroupName(self, ssv)
         USER::ENT *self
+        SV * ssv
         PPCODE:
         GValueArray *values;
-        GValue *value;
-        values = lu_ent_get(self, LU_GROUPNAME);
-        if (values != NULL) {
-                value = g_value_array_get_nth(values, 0);
-                if (G_VALUE_HOLDS_STRING(value)) {
+        GValue *value, val;
+        if ( SvIOK(ssv) && SvIV(ssv) == -65533) {
+                values = lu_ent_get(self, LU_GROUPNAME);
+                if (values != NULL) {
+                        value = g_value_array_get_nth(values, 0);
+                        if (G_VALUE_HOLDS_STRING(value)) {
                         XPUSHs(sv_2mortal(newSVpv(g_value_get_string(value), 0)));
-                } else if (G_VALUE_HOLDS_LONG(value)) {
-                        XPUSHs(sv_2mortal(newSVpv(g_strdup_printf("%ld", g_value_get_long(value)), 0)));
+                        } else if (G_VALUE_HOLDS_LONG(value)) {
+                                XPUSHs(sv_2mortal(newSVpv(g_strdup_printf("%ld", g_value_get_long(value)), 0)));
+                        }
                 }
+        } else if( SvPOK( ssv ) ) {
+                memset(&val, 0, sizeof(val));
+                g_value_init(&val, G_TYPE_STRING);
+                g_value_set_string(&val, SvPV(ssv,PL_na));
+                lu_ent_clear(self, LU_GROUPNAME);
+                lu_ent_add(self, LU_GROUPNAME, &val);
+        } else {
+                warn("XS_GroupName: Cannot make operation on LU_GROUPNAME attribute");
         }
 
 void 
-Ent_Uid(self)
+Ent_Uid(self, ssv)
         USER::ENT *self
+        SV *ssv;
         PPCODE:
         GValueArray *values;
-        GValue *value;
-        values = lu_ent_get(self, LU_UIDNUMBER);
-        if (values != NULL) {
-                value = g_value_array_get_nth(values, 0);
-                if (G_VALUE_HOLDS_LONG(value)) {
-                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
-                } else if (G_VALUE_HOLDS_STRING(value)) {
-                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+        GValue *value, val;
+        if ( SvIOK(ssv) ) {
+                if (SvIV(ssv) == -65533) {
+                        values = lu_ent_get(self, LU_UIDNUMBER);
+                        if (values != NULL) {
+                                value = g_value_array_get_nth(values, 0);
+                                if (G_VALUE_HOLDS_LONG(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
+                                } else if (G_VALUE_HOLDS_STRING(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+                                }
+                        }
+                } else {
+                        memset(&val, 0, sizeof(val));
+                        g_value_init(&val, G_TYPE_LONG);
+                        g_value_set_long(&val, (long)SvIV( ssv ));
+                        lu_ent_clear(self, LU_UIDNUMBER);
+                        lu_ent_add(self, LU_UIDNUMBER, &val);
                 }
+        } else {
+                warn("XS_Uid: Cannot make operation on LU_UIDNUMBER attribute");
         }
 
 void
-Ent_Gid(self)
+Ent_Gid(self, ssv)
         USER::ENT *self
+        SV *ssv;
         PPCODE:
         GValueArray *values;
-        GValue *value;
-        values = lu_ent_get(self, LU_GIDNUMBER);
-        if (values != NULL) {
-                value = g_value_array_get_nth(values, 0);
-                if (G_VALUE_HOLDS_LONG(value)) {
-                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
-                } else if (G_VALUE_HOLDS_STRING(value)) {
-                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+        GValue *value, val;
+        if ( SvIOK(ssv) ) { 
+                if (SvIV(ssv) == -65533) {
+                        values = lu_ent_get(self, LU_GIDNUMBER);
+                        if (values != NULL) {
+                                value = g_value_array_get_nth(values, 0);
+                                if (G_VALUE_HOLDS_LONG(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
+                                } else if (G_VALUE_HOLDS_STRING(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+                                }
+                        }
+                } else {
+                        memset(&val, 0, sizeof(val));
+                        g_value_init(&val, G_TYPE_LONG);
+                        g_value_set_long(&val, (long)SvIV( ssv ));
+                        lu_ent_clear(self, LU_GIDNUMBER);
+                        lu_ent_add(self, LU_GIDNUMBER, &val);
                 }
+        } else {
+                warn("XS_Gid: Cannot make operation on LU_GIDNUMBER attribute");
         }
 
 void 
-Ent_Gecos(self)
+Ent_Gecos(self, ssv)
         USER::ENT *self
+        SV *ssv;
         PPCODE:
         GValueArray *values;
-        GValue *value;
-        values = lu_ent_get(self, LU_GECOS);
-        if (values != NULL) {
-                value = g_value_array_get_nth(values, 0);
-                if (G_VALUE_HOLDS_STRING(value)) {
+        GValue *value, val;
+        if ( SvIOK(ssv) && SvIV(ssv) == -65533) {
+                values = lu_ent_get(self, LU_GECOS);
+                if (values != NULL) {
+                        value = g_value_array_get_nth(values, 0);
+                        if (G_VALUE_HOLDS_STRING(value)) {
                         XPUSHs(sv_2mortal(newSVpv(g_value_get_string(value), 0)));
-                } else if (G_VALUE_HOLDS_LONG(value)) {
-                        XPUSHs(sv_2mortal(newSVpv(g_strdup_printf("%ld", g_value_get_long(value)), 0)));
+                        } else if (G_VALUE_HOLDS_LONG(value)) {
+                                XPUSHs(sv_2mortal(newSVpv(g_strdup_printf("%ld", g_value_get_long(value)), 0)));
+                        }
                 }
+        } else if( SvPOK( ssv ) ) {
+                memset(&val, 0, sizeof(val));
+                g_value_init(&val, G_TYPE_STRING);
+                g_value_set_string(&val, SvPV(ssv,PL_na));
+                lu_ent_clear(self, LU_GECOS);
+                lu_ent_add(self, LU_GECOS, &val);
+        } else {
+                warn("XS_Gecos: Cannot make operation on LU_GECOS attribute");
         }
 
 void 
-Ent_HomeDir(self)
+Ent_HomeDir(self, ssv)
         USER::ENT *self
+        SV *ssv
         PPCODE:
         GValueArray *values;
-        GValue *value;
-        values = lu_ent_get(self, LU_HOMEDIRECTORY);
-        if (values != NULL) {
-                value = g_value_array_get_nth(values, 0);
-                if (G_VALUE_HOLDS_STRING(value)) {
+        GValue *value, val;
+        if ( SvIOK(ssv) && SvIV(ssv) == -65533) {
+                values = lu_ent_get(self, LU_HOMEDIRECTORY);
+                if (values != NULL) {
+                        value = g_value_array_get_nth(values, 0);
+                        if (G_VALUE_HOLDS_STRING(value)) {
                         XPUSHs(sv_2mortal(newSVpv(g_value_get_string(value), 0)));
-                } else if (G_VALUE_HOLDS_LONG(value)) {
-                        XPUSHs(sv_2mortal(newSVpv(g_strdup_printf("%ld", g_value_get_long(value)), 0)));
+                        } else if (G_VALUE_HOLDS_LONG(value)) {
+                                XPUSHs(sv_2mortal(newSVpv(g_strdup_printf("%ld", g_value_get_long(value)), 0)));
+                        }
                 }
+        } else if( SvPOK( ssv ) ) {
+                memset(&val, 0, sizeof(val));
+                g_value_init(&val, G_TYPE_STRING);
+                g_value_set_string(&val, SvPV(ssv,PL_na));
+                lu_ent_clear(self, LU_HOMEDIRECTORY);
+                lu_ent_add(self, LU_HOMEDIRECTORY, &val);
+        } else {
+                warn("XS_HomeDir: Cannot make operation on LU_HOMEDIRECTORY attribute");
         }
 
 void 
-Ent_LoginShell(self)
+Ent_LoginShell(self, ssv)
         USER::ENT *self
+        SV *ssv
         PPCODE:
         GValueArray *values;
-        GValue *value;
-        values = lu_ent_get(self, LU_LOGINSHELL);
-        if (values != NULL) {
-                value = g_value_array_get_nth(values, 0);
-                if (G_VALUE_HOLDS_STRING(value)) {
+        GValue *value, val;
+        if ( SvIOK(ssv) && SvIV(ssv) == -65533) {
+                values = lu_ent_get(self, LU_LOGINSHELL);
+                if (values != NULL) {
+                        value = g_value_array_get_nth(values, 0);
+                        if (G_VALUE_HOLDS_STRING(value)) {
                         XPUSHs(sv_2mortal(newSVpv(g_value_get_string(value), 0)));
-                } else if (G_VALUE_HOLDS_LONG(value)) {
-                        XPUSHs(sv_2mortal(newSVpv(g_strdup_printf("%ld", g_value_get_long(value)), 0)));
+                        } else if (G_VALUE_HOLDS_LONG(value)) {
+                                XPUSHs(sv_2mortal(newSVpv(g_strdup_printf("%ld", g_value_get_long(value)), 0)));
+                        }
                 }
+        } else if( SvPOK( ssv ) ) {
+                memset(&val, 0, sizeof(val));
+                g_value_init(&val, G_TYPE_STRING);
+                g_value_set_string(&val, SvPV(ssv,PL_na));
+                lu_ent_clear(self, LU_LOGINSHELL);
+                lu_ent_add(self, LU_LOGINSHELL, &val);
+        } else {
+                warn("XS_LoginShell: Cannot make operation on LU_LOGINSHELL attribute");
         }
 
 void 
-Ent_ShadowPass(self)
+Ent_ShadowPass(self, ssv)
         USER::ENT *self
+        SV *ssv
         PPCODE:
         GValueArray *values;
-        GValue *value;
-        values = lu_ent_get(self, LU_SHADOWPASSWORD);
-        if (values != NULL) {
-                value = g_value_array_get_nth(values, 0);
-                if (G_VALUE_HOLDS_STRING(value)) {
+        GValue *value, val;
+        if ( SvIOK(ssv) && SvIV(ssv) == -65533) {
+                values = lu_ent_get(self, LU_SHADOWPASSWORD);
+                if (values != NULL) {
+                        value = g_value_array_get_nth(values, 0);
+                        if (G_VALUE_HOLDS_STRING(value)) {
                         XPUSHs(sv_2mortal(newSVpv(g_value_get_string(value), 0)));
-                } else if (G_VALUE_HOLDS_LONG(value)) {
-                        XPUSHs(sv_2mortal(newSVpv(g_strdup_printf("%ld", g_value_get_long(value)), 0)));
+                        } else if (G_VALUE_HOLDS_LONG(value)) {
+                                XPUSHs(sv_2mortal(newSVpv(g_strdup_printf("%ld", g_value_get_long(value)), 0)));
+                        }
                 }
+        } else if( SvPOK( ssv ) ) {
+                memset(&val, 0, sizeof(val));
+                g_value_init(&val, G_TYPE_STRING);
+                g_value_set_string(&val, SvPV(ssv,PL_na));
+                lu_ent_clear(self, LU_SHADOWPASSWORD);
+                lu_ent_add(self, LU_SHADOWPASSWORD, &val);
+        } else {
+                warn("XS_ShadowPass: Cannot make operation on LU_SHADOWPASSWORD attribute");
         }
 
 void 
-Ent_ShadowWarn(self)
+Ent_ShadowWarn(self, ssv)
         USER::ENT *self
+        SV *ssv
         PPCODE:
         GValueArray *values;
-        GValue *value;
-        values = lu_ent_get(self, LU_SHADOWWARNING);
-        if (values != NULL) {
-                value = g_value_array_get_nth(values, 0);
-                if (G_VALUE_HOLDS_STRING(value)) {
+        GValue *value, val;
+        if ( SvIOK(ssv) && SvIV(ssv) == -65533) {
+                values = lu_ent_get(self, LU_SHADOWWARNING);
+                if (values != NULL) {
+                        value = g_value_array_get_nth(values, 0);
+                        if (G_VALUE_HOLDS_STRING(value)) {
                         XPUSHs(sv_2mortal(newSVpv(g_value_get_string(value), 0)));
-                } else if (G_VALUE_HOLDS_LONG(value)) {
-                        XPUSHs(sv_2mortal(newSVpv(g_strdup_printf("%ld", g_value_get_long(value)), 0)));
+                        } else if (G_VALUE_HOLDS_LONG(value)) {
+                                XPUSHs(sv_2mortal(newSVpv(g_strdup_printf("%ld", g_value_get_long(value)), 0)));
+                        }
                 }
+        } else if( SvPOK( ssv ) ) {
+                memset(&val, 0, sizeof(val));
+                g_value_init(&val, G_TYPE_STRING);
+                g_value_set_string(&val, SvPV(ssv,PL_na));
+                lu_ent_clear(self, LU_SHADOWWARNING);
+                lu_ent_add(self, LU_SHADOWWARNING, &val);
+        } else {
+                warn("XS_ShadowWarn: Cannot make operation on LU_SHADOWWARNING attribute");
         }
 
 void 
-Ent_ShadowLastChange(self)
+Ent_ShadowLastChange(self, ssv)
         USER::ENT *self
+        SV *ssv
         PPCODE:
         GValueArray *values;
-        GValue *value;
-        values = lu_ent_get(self, LU_SHADOWLASTCHANGE);
-        if (values != NULL) {
-                value = g_value_array_get_nth(values, 0);
-                if (G_VALUE_HOLDS_LONG(value)) {
-                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
-                } else if (G_VALUE_HOLDS_STRING(value)) {
-                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+        GValue *value, val;
+        if ( SvIOK(ssv) ) {
+                if (SvIV(ssv) == -65533) {
+                        values = lu_ent_get(self, LU_SHADOWLASTCHANGE);
+                        if (values != NULL) {
+                                value = g_value_array_get_nth(values, 0);
+                                if (G_VALUE_HOLDS_LONG(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
+                                } else if (G_VALUE_HOLDS_STRING(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+                                }
+                        }
+                } else {
+                        memset(&val, 0, sizeof(val));
+                        g_value_init(&val, G_TYPE_LONG);
+                        g_value_set_long(&val, (long)SvIV( ssv ));
+                        lu_ent_clear(self, LU_SHADOWLASTCHANGE);
+                        lu_ent_add(self, LU_SHADOWLASTCHANGE, &val);
                 }
+        } else {
+                warn("XS_ShadowLastChange: Cannot make operation on LU_SHADOWLASTCHANGE attribute");
         }
 
 void 
-Ent_ShadowMin(self)
+Ent_ShadowMin(self, ssv)
         USER::ENT *self
+        SV *ssv
         PPCODE:
         GValueArray *values;
-        GValue *value;
-        values = lu_ent_get(self, LU_SHADOWMIN);
-        if (values != NULL) {
-                value = g_value_array_get_nth(values, 0);
-                if (G_VALUE_HOLDS_LONG(value)) {
-                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
-                } else if (G_VALUE_HOLDS_STRING(value)) {
-                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+        GValue *value, val;
+        if ( SvIOK(ssv) ) {
+                if (SvIV(ssv) == -65533) {        
+                        values = lu_ent_get(self, LU_SHADOWMIN);
+                        if (values != NULL) {
+                                value = g_value_array_get_nth(values, 0);
+                                if (G_VALUE_HOLDS_LONG(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
+                                } else if (G_VALUE_HOLDS_STRING(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+                                }
+                        }
+                } else {
+                        memset(&val, 0, sizeof(val));
+                        g_value_init(&val, G_TYPE_LONG);
+                        g_value_set_long(&val, (long)SvIV( ssv ));
+                        lu_ent_clear(self, LU_SHADOWMIN);
+                        lu_ent_add(self, LU_SHADOWMIN, &val);
                 }
+        } else {
+                warn("XS_ShadowMin: Cannot make operation on LU_SHADOWMIN attribute");
         }
 
 void 
-Ent_ShadowMax(self)
+Ent_ShadowMax(self, ssv)
         USER::ENT *self
+        SV *ssv
         PPCODE:
         GValueArray *values;
-        GValue *value;
-        values = lu_ent_get(self, LU_SHADOWMAX);
-        if (values != NULL) {
-                value = g_value_array_get_nth(values, 0);
-                if (G_VALUE_HOLDS_LONG(value)) {
-                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
-                } else if (G_VALUE_HOLDS_STRING(value)) {
-                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+        GValue *value, val;
+        if ( SvIOK(ssv) ) {
+                if (SvIV(ssv) == -65533) {
+                        values = lu_ent_get(self, LU_SHADOWMAX);
+                        if (values != NULL) {
+                                value = g_value_array_get_nth(values, 0);
+                                if (G_VALUE_HOLDS_LONG(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
+                                } else if (G_VALUE_HOLDS_STRING(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+                                }
+                        }
+                } else {
+                        memset(&val, 0, sizeof(val));
+                        g_value_init(&val, G_TYPE_LONG);
+                        g_value_set_long(&val, (long)SvIV( ssv ));
+                        lu_ent_clear(self, LU_SHADOWMAX);
+                        lu_ent_add(self, LU_SHADOWMAX, &val);
                 }
+        } else {
+                warn("XS_ShadowMax: Cannot make operation on LU_SHADOWMAX attribute");
         }
 
 void 
-Ent_ShadowInact(self)
+Ent_ShadowInact(self, ssv)
         USER::ENT *self
+        SV *ssv
         PPCODE:
         GValueArray *values;
-        GValue *value;
-        values = lu_ent_get(self, LU_SHADOWINACTIVE);
-        if (values != NULL) {
-                value = g_value_array_get_nth(values, 0);
-                if (G_VALUE_HOLDS_LONG(value)) {
-                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
-                } else if (G_VALUE_HOLDS_STRING(value)) {
-                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+        GValue *value, val;
+        if ( SvIOK(ssv) ) {
+                if (SvIV(ssv) == -65533) {
+                        values = lu_ent_get(self, LU_SHADOWINACTIVE);
+                        if (values != NULL) {
+                                value = g_value_array_get_nth(values, 0);
+                                if (G_VALUE_HOLDS_LONG(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
+                                } else if (G_VALUE_HOLDS_STRING(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+                                }
+                        }
+                } else {
+                        memset(&val, 0, sizeof(val));
+                        g_value_init(&val, G_TYPE_LONG);
+                        g_value_set_long(&val, (long)SvIV( ssv ));
+                        lu_ent_clear(self, LU_SHADOWINACTIVE);
+                        lu_ent_add(self, LU_SHADOWINACTIVE, &val);
                 }
+        } else {
+                warn("XS_ShadowInact: Cannot make operation on LU_SHADOWINACTIVE attribute");
         }
 
 void 
-Ent_ShadowExpire(self)
+Ent_ShadowExpire(self, ssv)
         USER::ENT *self
+        SV *ssv
         PPCODE:
         GValueArray *values;
-        GValue *value;
-        values = lu_ent_get(self, LU_SHADOWEXPIRE);
-        if (values != NULL) {
-                value = g_value_array_get_nth(values, 0);
-                if (G_VALUE_HOLDS_LONG(value)) {
-                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
-                } else if (G_VALUE_HOLDS_STRING(value)) {
-                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+        GValue *value, val;
+        if ( SvIOK(ssv) ) {
+                if (SvIV(ssv) == -65533) {
+                        values = lu_ent_get(self, LU_SHADOWEXPIRE);
+                        if (values != NULL) {
+                                value = g_value_array_get_nth(values, 0);
+                                if (G_VALUE_HOLDS_LONG(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
+                                } else if (G_VALUE_HOLDS_STRING(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+                                }
+                        }
+                } else {
+                        memset(&val, 0, sizeof(val));
+                        g_value_init(&val, G_TYPE_LONG);
+                        g_value_set_long(&val, (long)SvIV( ssv ));
+                        lu_ent_clear(self, LU_SHADOWEXPIRE);
+                        lu_ent_add(self, LU_SHADOWEXPIRE, &val);
                 }
+        } else {
+                warn("XS_ShadowExpire: Cannot make operation on LU_SHADOWEXPIRE attribute");
         }
 
 void 
-Ent_ShadowFlag(self)
+Ent_ShadowFlag(self, ssv)
         USER::ENT *self
+        SV *ssv
         PPCODE:
         GValueArray *values;
-        GValue *value;
-        values = lu_ent_get(self, LU_SHADOWFLAG);
-        if (values != NULL) {
-                value = g_value_array_get_nth(values, 0);
-                if (G_VALUE_HOLDS_LONG(value)) {
-                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
-                } else if (G_VALUE_HOLDS_STRING(value)) {
-                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+        GValue *value, val;
+        if ( SvIOK(ssv) ) {
+                if ( SvIV(ssv) == -65533 ) {
+                        values = lu_ent_get(self, LU_SHADOWFLAG);
+                        if (values != NULL) {
+                                value = g_value_array_get_nth(values, 0);
+                                if (G_VALUE_HOLDS_LONG(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(g_value_get_long(value))));
+                                } else if (G_VALUE_HOLDS_STRING(value)) {
+                                        XPUSHs(sv_2mortal(newSViv(atol(g_value_get_string(value)))));
+                                }
+                        }
+                } else {
+                        memset(&val, 0, sizeof(val));
+                        g_value_init(&val, G_TYPE_LONG);
+                        g_value_set_long(&val, (long)SvIV( ssv ));
+                        lu_ent_clear(self, LU_SHADOWFLAG);
+                        lu_ent_add(self, LU_SHADOWFLAG, &val);
                 }
+        } else {
+                warn("XS_ShadowExpire: Cannot make operation on LU_SHADOWEXPIRE attribute");
         }
 
-HV * 
-Ent_get_attributes(self)
-	USER::ENT *self
-        CODE:
-        RETVAL = (HV*)sv_2mortal((SV*)newHV());
-        printf("%s", self->type);
-        switch (self->type) {
-                case lu_invalid:
-                        break;
-                case lu_user:
-                        hv_store(RETVAL, "type", 4, newSVpv("user", 0), 0);
-                        hv_store(RETVAL, "username", 8, newSVpv(get_name(self, LU_USERNAME), 0), 0);
-                        hv_store(RETVAL, "uid", 3, newSViv(get_int(self, LU_UIDNUMBER)), 0);
-                        hv_store(RETVAL, "gid", 3, newSViv(get_int(self, LU_GIDNUMBER)), 0);
-                        hv_store(RETVAL, "gecos", 5, newSVpv(get_name(self, LU_GECOS), 0), 0);
-                        hv_store(RETVAL, "home", 4, newSVpv(get_name(self, LU_HOMEDIRECTORY), 0), 0);
-                        hv_store(RETVAL, "shell", 5, newSVpv(get_name(self, LU_LOGINSHELL), 0), 0);
-                        hv_store(RETVAL, "shadowpass", 10, newSVpv(get_name(self, LU_SHADOWPASSWORD), 0), 0);
-                        hv_store(RETVAL, "shadowlastchange", 16, newSViv(get_int(self, LU_SHADOWLASTCHANGE)), 0);
-                        hv_store(RETVAL, "shadowmin", 9, newSViv(get_int(self, LU_SHADOWMIN)), 0);
-                        hv_store(RETVAL, "shadowmax", 9, newSViv(get_int(self, LU_SHADOWMAX)), 0);
-                        hv_store(RETVAL, "shadowwarning", 13, newSVpv(get_name(self, LU_SHADOWWARNING), 0), 0);
-                        hv_store(RETVAL, "shadowinact", 11, newSViv(get_int(self, LU_SHADOWINACTIVE)), 0);
-                        hv_store(RETVAL, "shadowexpire", 12, newSViv(get_int(self, LU_SHADOWEXPIRE)), 0);
-                        hv_store(RETVAL, "shadowflag", 10, newSViv(get_int(self, LU_SHADOWFLAG)), 0);
-                        break;
-                case lu_group:
-                        hv_store(RETVAL, "type", 4, newSVpv("group", 0), 0);
-                        hv_store(RETVAL, "groupname", 9, newSVpv(get_name(self, LU_GROUPNAME), 0), 0);
-                        hv_store(RETVAL, "gid", 3, newSViv(get_int(self, LU_GIDNUMBER)), 0);
-                        break;
-                default:
-                        break;
-        }
-        OUTPUT:
-        RETVAL
-
 MODULE = USER       PACKAGE = USER         PREFIX = User_
 	
 void