[BACK]Return to tcfs_dbmaint.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / tcfs

Diff for /src/usr.bin/tcfs/Attic/tcfs_dbmaint.c between version 1.6 and 1.7

version 1.6, 2000/06/19 20:35:47 version 1.7, 2000/06/19 22:42:28
Line 30 
Line 30 
 #define PERM_SECURE     (S_IRUSR|S_IWUSR)  #define PERM_SECURE     (S_IRUSR|S_IWUSR)
   
 int  int
 tcfspwdbr_new (tcfspwdb **new)  tcfspwdbr_new(tcfspwdb **new)
 {  {
         *new = (tcfspwdb *)calloc(1, sizeof(tcfspwdb));          *new = (tcfspwdb *)calloc(1, sizeof(tcfspwdb));
   
Line 41 
Line 41 
 }  }
   
 int  int
 tcfsgpwdbr_new (tcfsgpwdb **new)  tcfsgpwdbr_new(tcfsgpwdb **new)
 {  {
         *new = (tcfsgpwdb *)calloc(1, sizeof(tcfsgpwdb));          *new = (tcfsgpwdb *)calloc(1, sizeof(tcfsgpwdb));
   
Line 52 
Line 52 
 }  }
   
 int  int
 tcfspwdbr_edit (tcfspwdb **tmp, int flags,...)  tcfspwdbr_edit (tcfspwdb **tmp, int flags, ...)
 {  {
         va_list argv;          va_list argv;
         char *d;          char *d;
   
         if (!*tmp)          if (!*tmp)
                 if (!tcfspwdbr_new (tmp))                  if (!tcfspwdbr_new(tmp))
                         return 0;                          return (0);
   
         va_start (argv, flags);          va_start(argv, flags);
   
         if (flags & F_USR) {          if (flags & F_USR) {
                 d = va_arg (argv, char *);                  d = va_arg(argv, char *);
                 strcpy ((*tmp)->user, d);                  strcpy((*tmp)->user, d);
         }          }
   
         if (flags & F_PWD) {          if (flags & F_PWD) {
                 d = va_arg (argv, char *);                  d = va_arg(argv, char *);
                 strcpy ((*tmp)->upw, d);                  strcpy((*tmp)->upw, d);
         }          }
   
         va_end (argv);          va_end(argv);
         return 1;          return (1);
 }  }
   
 int  int
 tcfsgpwdbr_edit (tcfsgpwdb **tmp, int flags,...)  tcfsgpwdbr_edit(tcfsgpwdb **tmp, int flags, ...)
 {  {
         va_list argv;          va_list argv;
         char *d;          char *d;
   
         if (!*tmp)          if (!*tmp)
                 if (!tcfsgpwdbr_new (tmp))                  if (!tcfsgpwdbr_new(tmp))
                         return 0;                          return (0);
   
         va_start (argv, flags);          va_start(argv, flags);
   
         if (flags & F_USR) {          if (flags & F_USR) {
                 d = va_arg (argv, char *);                  d = va_arg(argv, char *);
                 strcpy ((*tmp)->user, d);                  strcpy((*tmp)->user, d);
         }          }
   
         if (flags & F_GKEY) {          if (flags & F_GKEY) {
                 d = va_arg (argv, char *);                  d = va_arg(argv, char *);
                 strcpy ((*tmp)->gkey, d);                  strcpy((*tmp)->gkey, d);
         }          }
   
         if (flags & F_GID) {          if (flags & F_GID) {
                 gid_t d;                  gid_t d;
                 d = va_arg (argv, gid_t);                  d = va_arg(argv, gid_t);
                 (*tmp)->gid = d;                  (*tmp)->gid = d;
         }          }
   
         if (flags & F_MEMBERS) {          if (flags & F_MEMBERS) {
                 int d;                  int d;
                 d = va_arg (argv, int);                  d = va_arg(argv, int);
                 (*tmp)->n = d;                  (*tmp)->n = d;
         }          }
   
         if (flags & F_THRESHOLD) {          if (flags & F_THRESHOLD) {
                 int d;                  int d;
                 d = va_arg (argv, int);                  d = va_arg(argv, int);
                 (*tmp)->soglia = d;                  (*tmp)->soglia = d;
         }          }
   
         va_end (argv);          va_end(argv);
         return (1);          return (1);
 }  }
   
 int  int
 tcfspwdbr_read (tcfspwdb *t, int flags,...)  tcfspwdbr_read(tcfspwdb *t, int flags, ...)
 {  {
         va_list argv;          va_list argv;
         char *d;          char *d;
   
         va_start (argv, flags);          va_start(argv, flags);
   
         if (flags & F_USR) {          if (flags & F_USR) {
                 d = va_arg (argv, char *);                  d = va_arg(argv, char *);
                 memset (d, 0, UserLen);                  memset(d, 0, UserLen);
                 strcpy (d, t->user);                  strcpy(d, t->user);
         }          }
   
         if (flags & F_PWD) {          if (flags & F_PWD) {
                 d = va_arg (argv, char *);                  d = va_arg(argv, char *);
                 memset (d, 0, PassLen);                  memset(d, 0, PassLen);
                 strcpy (d, t->upw);                  strcpy(d, t->upw);
         }          }
   
         va_end (argv);          va_end(argv);
         return 0;          return (0);
 }  }
   
 int  int
 tcfsgpwdbr_read (tcfsgpwdb *t, int flags,...)  tcfsgpwdbr_read(tcfsgpwdb *t, int flags, ...)
 {  {
         va_list argv;          va_list argv;
         char *d;          char *d;
   
         va_start (argv, flags);          va_start(argv, flags);
   
         if (flags & F_USR) {          if (flags & F_USR) {
                 d = va_arg (argv, char *);                  d = va_arg(argv, char *);
                 strcpy (d, t->user);                  strcpy(d, t->user);
         }          }
   
         if (flags & F_GKEY) {          if (flags & F_GKEY) {
                 d = va_arg (argv, char *);                  d = va_arg(argv, char *);
                 strcpy (d, t->gkey);                  strcpy(d, t->gkey);
         }          }
   
         if (flags & F_GID) {          if (flags & F_GID) {
                 gid_t *d;                  gid_t *d;
   
                 d = va_arg (argv, gid_t *);                  d = va_arg(argv, gid_t *);
                 memcpy (d, &t->gid, sizeof (gid_t));                  memcpy(d, &t->gid, sizeof (gid_t));
         }          }
         /* Incomplete... */          /* Incomplete... */
   
         va_end (argv);          va_end(argv);
         return 0;          return (0);
 }  }
   
 void  void
 tcfspwdbr_dispose (tcfspwdb *t)  tcfspwdbr_dispose(tcfspwdb *t)
 {  {
         free ((void *)t);          free((void *)t);
 }  }
   
 void  void
 tcfsgpwdbr_dispose (tcfsgpwdb *t)  tcfsgpwdbr_dispose(tcfsgpwdb *t)
 {  {
         free ((void *)t);          free((void *)t);
 }  }
   
 tcfspwdb *  tcfspwdb *
 tcfs_getpwnam (char *user, tcfspwdb **dest)  tcfs_getpwnam(char *user, tcfspwdb **dest)
 {  {
         DB *pdb;          DB *pdb;
         DBT srchkey, r;          DBT srchkey, r;
   
         if (!*dest)          if (!*dest)
                 if (!tcfspwdbr_new (dest))                  if (!tcfspwdbr_new(dest))
                         return NULL;                          return (NULL);
   
         pdb = dbopen (TCFSPWDB, O_RDONLY, 0, DB_HASH, NULL);          pdb = dbopen(TCFSPWDB, O_RDONLY, 0, DB_HASH, NULL);
         if (!pdb)          if (!pdb)
                 return NULL;                  return (NULL);
   
         srchkey.data = user;          srchkey.data = user;
         srchkey.size = (int) strlen (user);          srchkey.size = (int)strlen(user);
   
         if (pdb->get(pdb, &srchkey, &r, 0)) {          if (pdb->get(pdb, &srchkey, &r, 0)) {
                 pdb->close(pdb);                  pdb->close(pdb);
                 return 0;                  return (0);
         }          }
   
         if (r.size != sizeof(tcfspwdb)) {          if (r.size != sizeof(tcfspwdb)) {
                 fprintf(stderr, "db: incorrect record size: %d != %d\n",                  fprintf(stderr, "db: incorrect record size: %d != %d\n",
                         r.size, sizeof(tcfspwdb));                          r.size, sizeof(tcfspwdb));
                 pdb->close(pdb);                  pdb->close(pdb);
                 return 0;                  return (0);
         }          }
   
         memcpy (*dest, r.data, sizeof (tcfspwdb));          memcpy(*dest, r.data, sizeof(tcfspwdb));
   
         pdb->close (pdb);          pdb->close(pdb);
   
         return (tcfspwdb *)*dest;          return ((tcfspwdb *)*dest);
 }  }
   
 tcfsgpwdb *  tcfsgpwdb *
 tcfs_ggetpwnam (char *user, gid_t gid, tcfsgpwdb **dest)  tcfs_ggetpwnam(char *user, gid_t gid, tcfsgpwdb **dest)
 {  {
         DB *pdb;          DB *pdb;
         DBT srchkey, r;          DBT srchkey, r;
Line 232 
Line 232 
         int res;          int res;
   
         if (!*dest)          if (!*dest)
                 if (!tcfsgpwdbr_new (dest))                  if (!tcfsgpwdbr_new(dest))
                         return NULL;                          return (NULL);
   
         pdb = dbopen (TCFSGPWDB, O_RDONLY, 0, DB_HASH, NULL);          pdb = dbopen(TCFSGPWDB, O_RDONLY, 0, DB_HASH, NULL);
         if (!pdb)          if (!pdb)
                 return NULL;                  return (NULL);
   
         key = (char*)calloc(strlen(user)+4/*gid lenght*/+1/*null*/,sizeof(char));          key = (char*)calloc(strlen(user)+4/*gid lenght*/+1/*null*/,sizeof(char));
         if (!key)          if (!key)
                 return NULL;                  return (NULL);
   
         sprintf (key, "%s\33%d\0", user, (int)gid);          sprintf(key, "%s\33%d\0", user, (int)gid);
         srchkey.data = key;          srchkey.data = key;
         srchkey.size = (int)strlen (key);          srchkey.size = (int)strlen(key);
   
         if ((res = pdb->get(pdb, &srchkey, &r, 0))) {          if ((res = pdb->get(pdb, &srchkey, &r, 0))) {
                 if (res == -1)                  if (res == -1)
                         perror("dbget");                          perror("dbget");
                 pdb->close (pdb);                  pdb->close(pdb);
                 return (NULL);                  return (NULL);
         }          }
   
         memcpy (*dest, r.data, sizeof (tcfsgpwdb));          memcpy(*dest, r.data, sizeof(tcfsgpwdb));
   
         pdb->close (pdb);          pdb->close(pdb);
   
         return (*dest);          return (*dest);
 }  }
   
 int  int
 tcfs_putpwnam (char *user, tcfspwdb *src, int flags)  tcfs_putpwnam(char *user, tcfspwdb *src, int flags)
 {  {
         DB *pdb;          DB *pdb;
         static DBT srchkey, d;          static DBT srchkey, d;
         int open_flag = 0, res;          int open_flag = 0, res;
   
         open_flag = O_RDWR|O_EXCL;          open_flag = O_RDWR|O_EXCL;
         if (access (TCFSPWDB, F_OK) < 0)          if (access(TCFSPWDB, F_OK) < 0)
                 open_flag |= O_CREAT;                  open_flag |= O_CREAT;
   
         pdb = dbopen (TCFSPWDB, open_flag, PERM_SECURE, DB_HASH, NULL);          pdb = dbopen(TCFSPWDB, open_flag, PERM_SECURE, DB_HASH, NULL);
         if (!pdb)          if (!pdb)
                 return 0;                  return (0);
   
         srchkey.data = user;          srchkey.data = user;
         srchkey.size = (int)strlen (user);          srchkey.size = (int)strlen(user);
   
         if (flags != U_DEL) {          if (flags != U_DEL) {
                 d.data = (char *)src;                  d.data = (char *)src;
Line 285 
Line 285 
   
                 if (pdb->put(pdb, &srchkey, &d, 0) == -1) {                  if (pdb->put(pdb, &srchkey, &d, 0) == -1) {
                         fprintf(stderr, "db: put failed\n");                          fprintf(stderr, "db: put failed\n");
                         pdb->close (pdb);                          pdb->close(pdb);
                         return 0;                          return (0);
                 }                  }
         } else if ((res = pdb->del (pdb, &srchkey, 0))) {          } else if ((res = pdb->del(pdb, &srchkey, 0))) {
                 fprintf(stderr, "db: del failed: %s\n",                  fprintf(stderr, "db: del failed: %s\n",
                         res == -1 ? "error" : "not found");                          res == -1 ? "error" : "not found");
                 pdb->close (pdb);                  pdb->close(pdb);
                 return 0;                  return (0);
         }          }
   
         pdb->close (pdb);          pdb->close(pdb);
         return 1;          return (1);
 }  }
   
 int  int
 tcfs_gputpwnam (char *user, tcfsgpwdb *src, int flags)  tcfs_gputpwnam(char *user, tcfsgpwdb *src, int flags)
 {  {
         DB *pdb;          DB *pdb;
         static DBT srchkey, d;          static DBT srchkey, d;
Line 308 
Line 308 
         char *key;          char *key;
   
         open_flag = O_RDWR|O_EXCL;          open_flag = O_RDWR|O_EXCL;
         if (access (TCFSGPWDB, F_OK) < 0)          if (access(TCFSGPWDB, F_OK) < 0)
                 open_flag |= O_CREAT;                  open_flag |= O_CREAT;
   
         pdb = dbopen (TCFSGPWDB, open_flag, PERM_SECURE, DB_HASH, NULL);          pdb = dbopen(TCFSGPWDB, open_flag, PERM_SECURE, DB_HASH, NULL);
         if (!pdb) {          if (!pdb) {
                 perror("dbopen");                  perror("dbopen");
                 return 0;                  return (0);
         }          }
   
         key = (char *) calloc (strlen(src->user) + 4 + 1, sizeof(char));          key = (char *)calloc(strlen(src->user) + 4 + 1, sizeof(char));
         sprintf (key, "%s\33%d\0", src->user, src->gid);          sprintf(key, "%s\33%d\0", src->user, src->gid);
   
         srchkey.data = key;          srchkey.data = key;
         srchkey.size = strlen (key);          srchkey.size = strlen(key);
   
         if (flags != U_DEL) {          if (flags != U_DEL) {
                 d.data = (char *)src;                  d.data = (char *)src;
                 d.size = sizeof(tcfsgpwdb);                  d.size = sizeof(tcfsgpwdb);
   
                 if (pdb->put (pdb, &srchkey, &d, 0) == -1) {                  if (pdb->put(pdb, &srchkey, &d, 0) == -1) {
                         fprintf(stderr, "db: put failed\n");                          fprintf(stderr, "db: put failed\n");
                         pdb->close (pdb);                          pdb->close(pdb);
                         return 0;                          return (0);
                 }                  }
         } else if (pdb->del (pdb, &srchkey, 0)) {          } else if (pdb->del(pdb, &srchkey, 0)) {
                 fprintf(stderr, "db: del failed\n");                  fprintf(stderr, "db: del failed\n");
                 pdb->close (pdb);                  pdb->close(pdb);
                 return 0;                  return (0);
         }          }
   
         pdb->close (pdb);          pdb->close(pdb);
         return 1;          return (1);
 }  }
   
 int  int
 tcfs_rmgroup (gid_t gid)  tcfs_rmgroup(gid_t gid)
 {  {
         DB *gdb;          DB *gdb;
         DBT dbkey;          DBT dbkey;
   
         gdb = dbopen(TCFSGPWDB, O_RDWR|O_EXCL, PERM_SECURE, DB_HASH, NULL);          gdb = dbopen(TCFSGPWDB, O_RDWR|O_EXCL, PERM_SECURE, DB_HASH, NULL);
         if (!gdb)          if (!gdb)
                 return 0;                  return (0);
   
         if (gdb->seq(gdb, &dbkey, NULL, R_FIRST))          if (gdb->seq(gdb, &dbkey, NULL, R_FIRST))
                 dbkey.data = NULL;                  dbkey.data = NULL;
Line 361 
Line 361 
                 tmp = (char*)calloc(1024, sizeof(char));                  tmp = (char*)calloc(1024, sizeof(char));
   
                 sprintf(tmp, "\33%d\0", gid);                  sprintf(tmp, "\33%d\0", gid);
                 if (strstr (dbkey.data, tmp)) {                  if (strstr(dbkey.data, tmp)) {
                         if (gdb->del(gdb, &dbkey, 0)) {                          if (gdb->del(gdb, &dbkey, 0)) {
                                 gdb->close (gdb);                                  gdb->close(gdb);
                                   free(tmp);
                                 free (tmp);                                  return (0);
                                 return 0;  
                         }                          }
                 }                  }
                 free (tmp);                  free(tmp);
   
                 if (gdb->seq(gdb, &dbkey, NULL, R_NEXT)) {                  if (gdb->seq(gdb, &dbkey, NULL, R_NEXT)) {
                         gdb->close(gdb);                          gdb->close(gdb);
Line 377 
Line 376 
                 }                  }
         }          }
   
         gdb->close (gdb);          gdb->close(gdb);
         return (1);          return (1);
 }  }
   
   
 int  int
 tcfs_group_chgpwd (char *user, gid_t gid, char *old, char *new)  tcfs_group_chgpwd(char *user, gid_t gid, char *old, char *new)
 {  {
         tcfsgpwdb *group_info = NULL;          tcfsgpwdb *group_info = NULL;
         unsigned char *key;          unsigned char *key;
   
         key = (unsigned char *)calloc(UUGKEYSIZE + 1, sizeof (char));          key = (unsigned char *)calloc(UUGKEYSIZE + 1, sizeof (char));
         if (!key)          if (!key)
                 return 0;                  return (0);
   
         if (!tcfs_decrypt_key (old, group_info->gkey, key, GKEYSIZE))          if (!tcfs_decrypt_key(old, group_info->gkey, key, GKEYSIZE))
                 return 0;                  return (0);
   
         if (!tcfs_encrypt_key (new, key, GKEYSIZE, group_info->gkey,          if (!tcfs_encrypt_key(new, key, GKEYSIZE, group_info->gkey,
                                UUGKEYSIZE + 1))                                 UUGKEYSIZE + 1))
                 return 0;                  return (0);
   
         if (!tcfs_gputpwnam (user, group_info, U_CHG))          if (!tcfs_gputpwnam(user, group_info, U_CHG))
                 return 0;                  return (0);
   
         free (group_info);          free(group_info);
         free (key);          free(key);
   
         return 1;          return (1);
 }  }
   
 int  int
 tcfs_chgpwd (char *user, char *old, char *new)  tcfs_chgpwd(char *user, char *old, char *new)
 {  {
         tcfspwdb *user_info=NULL;          tcfspwdb *user_info = NULL;
         unsigned char *key;          unsigned char *key;
   
         key = (unsigned char*)calloc(UUKEYSIZE + 1, sizeof(char));          key = (unsigned char*)calloc(UUKEYSIZE + 1, sizeof(char));
   
         if (!tcfs_getpwnam (user, &user_info))          if (!tcfs_getpwnam(user, &user_info))
                 return 0;                  return (0);
   
         if (!tcfs_decrypt_key (old,  user_info->upw, key, KEYSIZE))          if (!tcfs_decrypt_key(old,  user_info->upw, key, KEYSIZE))
                 return 0;                  return (0);
   
         if (!tcfs_encrypt_key (new, key, KEYSIZE, user_info->upw, UUKEYSIZE + 1))          if (!tcfs_encrypt_key(new, key, KEYSIZE, user_info->upw, UUKEYSIZE + 1))
                 return 0;                  return (0);
   
         if (!tcfs_putpwnam (user, user_info, U_CHG))          if (!tcfs_putpwnam(user, user_info, U_CHG))
                 return 0;                  return (0);
   
         free (user_info);          free(user_info);
         free (key);          free(key);
   
         return 1;          return (1);
 }  }
   
 int  int
 tcfs_chgpassword (char *user, char *old, char *new)  tcfs_chgpassword(char *user, char *old, char *new)
 {  {
         int error1=0;          int error1=0;
         DB *gpdb;          DB *gpdb;
Line 444 
Line 443 
   
         ckey = (unsigned char*)calloc(UUGKEYSIZE + 1, sizeof(char));          ckey = (unsigned char*)calloc(UUGKEYSIZE + 1, sizeof(char));
         if (!ckey)          if (!ckey)
                 return 0;                  return (0);
   
         gpdb = dbopen (TCFSGPWDB, O_RDWR|O_EXCL, PERM_SECURE, DB_HASH, NULL);          gpdb = dbopen(TCFSGPWDB, O_RDWR|O_EXCL, PERM_SECURE, DB_HASH, NULL);
         if (!gpdb)          if (!gpdb)
                 return 0;                  return (0);
   
         error1 = tcfs_chgpwd (user, old, new);          error1 = tcfs_chgpwd(user, old, new);
         if (!error1)          if (!error1)
                 return 0;                  return (0);
   
         /* Reencrypt group shares */          /* Reencrypt group shares */
         if (gpdb->seq(gpdb, &key, NULL, R_FIRST))          if (gpdb->seq(gpdb, &key, NULL, R_FIRST))
                 key.data = NULL;                  key.data = NULL;
   
         while (key.data) {          while (key.data) {
                 if (strncmp (user, key.data, strlen(user))) {                  if (strncmp(user, key.data, strlen(user))) {
                         if (gpdb->seq(gpdb, &key, NULL, R_NEXT))                          if (gpdb->seq(gpdb, &key, NULL, R_NEXT))
                             key.data = NULL;                              key.data = NULL;
                         continue;                          continue;
Line 467 
Line 466 
   
                 gpdb->get(gpdb, &key, &found, 0);                  gpdb->get(gpdb, &key, &found, 0);
   
                 if (!tcfs_decrypt_key (old, ((tcfsgpwdb *)found.data)->gkey, ckey, GKEYSIZE))                  if (!tcfs_decrypt_key(old, ((tcfsgpwdb *)found.data)->gkey, ckey, GKEYSIZE))
                         return 0;                          return (0);
   
                 if (!tcfs_encrypt_key (new, ckey, GKEYSIZE, ((tcfsgpwdb *)found.data)->gkey, UUGKEYSIZE + 1))                  if (!tcfs_encrypt_key(new, ckey, GKEYSIZE, ((tcfsgpwdb *)found.data)->gkey, UUGKEYSIZE + 1))
                         return 0;                          return (0);
   
                 if (gpdb->put (gpdb, &key, &found, 0)) {                  if (gpdb->put(gpdb, &key, &found, 0)) {
                         free (ckey);                          free(ckey);
                           gpdb->close(gpdb);
                         gpdb->close (gpdb);  
                         return (0);                          return (0);
                 }                  }
   
                 free (ckey);                  free(ckey);
   
                 if (gpdb->seq(gpdb, &key, NULL, R_NEXT))                  if (gpdb->seq(gpdb, &key, NULL, R_NEXT))
                     key.data = NULL;                          key.data = NULL;
         }          }
   
         return 1;          return (1);
 }  }
Legend:
Removed from v.1.6  
changed lines
  Added in v.1.7