/*
* lftp - file transfer program
*
* Copyright (c) 1996-2012 by Alexander V. Lukyanov (lav@yars.free.net)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <config.h>
#include <pwd.h>
#include <grp.h>
#include <string.h>
#include <ctype.h>
#include "IdNameCache.h"
void IdNameCache::init()
{
memset(table_id,0,sizeof(table_id));
memset(table_name,0,sizeof(table_name));
}
void IdNameCache::free_list(IdNamePair *list)
{
while(list)
{
IdNamePair *next=list->next;
delete list;
list=next;
}
}
void IdNameCache::free()
{
for(int i=0; i<table_size; i++)
{
free_list(table_id[i]);
free_list(table_name[i]);
}
}
void IdNameCache::add(unsigned h,IdNamePair **p,IdNamePair *r)
{
r->next=p[h];
p[h]=r;
}
IdNamePair *IdNameCache::lookup(int id)
{
unsigned h=hash(id);
for(IdNamePair *scan=table_id[h]; scan; scan=scan->next)
if(id==scan->id)
return scan;
IdNamePair *r=get_record(id);
if(!r)
r=new IdNamePair(id,0);
add(h,table_id,r);
if(r->name)
add(hash(r->name),table_name,new IdNamePair(r));
return r;
}
IdNamePair *IdNameCache::lookup(const char *name)
{
unsigned h=hash(name);
for(IdNamePair *scan=table_name[h]; scan; scan=scan->next)
if(!xstrcmp(name,scan->name))
return scan;
IdNamePair *r=get_record(name);
if(!r)
r=new IdNamePair(-1,name);
add(h,table_name,r);
if(r->id!=-1)
add(hash(r->id),table_id,new IdNamePair(r));
return r;
}
const char *IdNameCache::Lookup(int id)
{
const char *name=lookup(id)->name;
if(name && name[0])
return name;
static char buf[32];
snprintf(buf,sizeof(buf),"%d",id);
return buf;
}
int IdNameCache::Lookup(const char *name)
{
return lookup(name)->id;
}
IdNameCache::IdNameCache()
{
init();
}
IdNameCache::~IdNameCache()
{
free();
}
int IdNameCache::Do()
{
if(expire_timer && expire_timer->Stopped())
Delete(this);
return STALL;
}
unsigned IdNameCache::hash(int id)
{
return unsigned(id)%table_size;
}
unsigned IdNameCache::hash(const char *name)
{
unsigned h=0;
while(*name)
h+=(h<<4)+*name++;
return h%table_size;
}
IdNamePair *PasswdCache::get_record(int id)
{
struct passwd *p=getpwuid(id);
if(!p)
return 0;
return new IdNamePair(p->pw_uid,p->pw_name);
}
IdNamePair *GroupCache::get_record(int id)
{
struct group *p=getgrgid(id);
if(!p)
return 0;
return new IdNamePair(p->gr_gid,p->gr_name);
}
IdNamePair *IdNameCache::get_record(const char *name)
{
int id,n;
if(sscanf(name,"%d%n",&id,&n)==1 && !name[n])
return new IdNamePair(id,name);
return 0;
}
IdNamePair *PasswdCache::get_record(const char *name)
{
struct passwd *p=getpwnam(name);
if(p)
return new IdNamePair(p->pw_uid,name);
return IdNameCache::get_record(name);
}
IdNamePair *GroupCache::get_record(const char *name)
{
struct group *p=getgrnam(name);
if(p)
return new IdNamePair(p->gr_gid,name);
return IdNameCache::get_record(name);
}
PasswdCache *PasswdCache::instance;
GroupCache *GroupCache::instance;
PasswdCache *PasswdCache::GetInstance()
{
if(instance)
return instance;
instance=new PasswdCache();
instance->SetExpireTimer(new Timer(30));
return instance;
}
GroupCache *GroupCache::GetInstance()
{
if(instance)
return instance;
instance=new GroupCache();
instance->SetExpireTimer(new Timer(30));
return instance;
}
PasswdCache::~PasswdCache()
{
if(this==instance)
instance=0;
}
GroupCache::~GroupCache()
{
if(this==instance)
instance=0;
}