libnpfs/simpleusers.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include "npfs.h"
   4 #include "npfsimpl.h"
   5
   6 static struct Npusercache {
   7         pthread_mutex_t lock;
   8         Npuser* users;
   9 } usercache = { PTHREAD_MUTEX_INITIALIZER, 0 };
  10
  11 static struct Npgroupcache {
  12         pthread_mutex_t lock;
  13         Npgroup* groups;
  14 } groupcache = { PTHREAD_MUTEX_INITIALIZER, 0 };
  15
  16 static Npuser *
  17 np_simpl_uname2user(Npuserpool *up, char *uname)
  18 {
  19         Npuser *u;
  20
  21         pthread_mutex_lock(&usercache.lock);
  22         for(u = usercache.users; u; u = u->next) {
  23                 if(strcmp(u->uname, uname) == 0)
  24                         break;
  25         }
  26         if(!u) {
  27                 u = np_malloc(sizeof(*u) + strlen(uname) + 1);
  28                 pthread_mutex_init(&u->lock, NULL);
  29                 u->refcount = 1;
  30                 u->upool = up;
  31                 u->uid = -1;
  32                 u->uname = (char *)u + sizeof(*u);
  33                 strcpy(u->uname, uname);
  34                 u->dfltgroup = NULL;
  35                 u->ngroups = 0;
  36                 u->groups = NULL;
  37                 u->next = NULL;
  38                 u->dfltgroup = (*up->gname2group)(up, uname);
  39
  40                 u->next = usercache.users;
  41                 usercache.users = u;
  42         }
  43         np_user_incref(u);
  44         pthread_mutex_unlock(&usercache.lock);
  45         return u;
  46 }
  47
  48 static Npuser *
  49 np_simpl_uid2user(Npuserpool *up, u32 uid)
  50 {
  51         return NULL;
  52 }
  53
  54 static Npgroup *
  55 np_simpl_gname2group(Npuserpool *up, char *gname)
  56 {
  57         Npgroup *g;
  58
  59         pthread_mutex_lock(&groupcache.lock);
  60         for(g = groupcache.groups; g; g = g->next) {
  61                 if(strcmp(g->gname, gname) == 0)
  62                         break;
  63         }
  64
  65         if(!g) {
  66                 g = np_malloc(sizeof(*g) + strlen(gname) + 1);
  67                 pthread_mutex_init(&g->lock, NULL);
  68                 g->refcount = 1;
  69                 g->upool = up;
  70                 g->gid = -1;
  71                 g->gname = (char *)g + sizeof(*g);
  72                 strcpy(g->gname, gname);
  73
  74                 g->next = groupcache.groups;
  75                 groupcache.groups = g;
  76         }
  77         np_group_incref(g);
  78         pthread_mutex_unlock(&groupcache.lock);
  79         return g;
  80 }
  81
  82 static Npgroup *
  83 np_simpl_gid2group(Npuserpool *up, u32 gid)
  84 {
  85         return NULL;
  86 }
  87
  88 static int
  89 np_simpl_ismember(Npuserpool *up, Npuser *u, Npgroup *g)
  90 {
  91         return 0; // XXX something fancier?
  92 }
  93
  94 static void
  95 np_simpl_udestroy(Npuserpool *up, Npuser *u)
  96 {
  97 }
  98
  99 static void
 100 np_simpl_gdestroy(Npuserpool *up, Npgroup *g)
 101 {
 102 }
 103
 104 static Npuserpool upool = {
 105         NULL,
 106         np_simpl_uname2user,
 107         np_simpl_uid2user,
 108         np_simpl_gname2group,
 109         np_simpl_gid2group,
 110         np_simpl_ismember,
 111         np_simpl_udestroy,
 112         np_simpl_gdestroy,
 113 };
 114
 115 Npuserpool *np_default_users = &upool;