mirror of
https://github.com/samba-team/samba.git
synced 2025-12-12 12:23:50 +03:00
moved some more locking routines to locking.c, and moved replacement
routines for broken OSes from util.c to replace.c.
This commit is contained in:
Andrew Tridgell
@@ -266,136 +266,6 @@ va_dcl
|
||||
return(0);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
routine to do file locking
|
||||
****************************************************************************/
|
||||
BOOL fcntl_lock(int fd,int op,uint32 offset,uint32 count,int type)
|
||||
{
|
||||
#if HAVE_FCNTL_LOCK
|
||||
struct flock lock;
|
||||
int ret;
|
||||
|
||||
#if 1
|
||||
uint32 mask = 0xC0000000;
|
||||
|
||||
/* make sure the count is reasonable, we might kill the lockd otherwise */
|
||||
count &= ~mask;
|
||||
|
||||
/* the offset is often strange - remove 2 of its bits if either of
|
||||
the top two bits are set. Shift the top ones by two bits. This
|
||||
still allows OLE2 apps to operate, but should stop lockd from
|
||||
dieing */
|
||||
if ((offset & mask) != 0)
|
||||
offset = (offset & ~mask) | ((offset & mask) >> 2);
|
||||
#else
|
||||
unsigned long mask = ((unsigned)1<<31);
|
||||
|
||||
/* interpret negative counts as large numbers */
|
||||
if (count < 0)
|
||||
count &= ~mask;
|
||||
|
||||
/* no negative offsets */
|
||||
offset &= ~mask;
|
||||
|
||||
/* count + offset must be in range */
|
||||
while ((offset < 0 || (offset + count < 0)) && mask)
|
||||
{
|
||||
offset &= ~mask;
|
||||
mask = mask >> 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
DEBUG(5,("fcntl_lock %d %d %d %d %d\n",fd,op,(int)offset,(int)count,type));
|
||||
|
||||
lock.l_type = type;
|
||||
lock.l_whence = SEEK_SET;
|
||||
lock.l_start = (int)offset;
|
||||
lock.l_len = (int)count;
|
||||
lock.l_pid = 0;
|
||||
|
||||
errno = 0;
|
||||
|
||||
ret = fcntl(fd,op,&lock);
|
||||
|
||||
if (errno != 0)
|
||||
DEBUG(3,("fcntl lock gave errno %d (%s)\n",errno,strerror(errno)));
|
||||
|
||||
/* a lock query */
|
||||
if (op == F_GETLK)
|
||||
{
|
||||
if ((ret != -1) &&
|
||||
(lock.l_type != F_UNLCK) &&
|
||||
(lock.l_pid != 0) &&
|
||||
(lock.l_pid != getpid()))
|
||||
{
|
||||
DEBUG(3,("fd %d is locked by pid %d\n",fd,lock.l_pid));
|
||||
return(True);
|
||||
}
|
||||
|
||||
/* it must be not locked or locked by me */
|
||||
return(False);
|
||||
}
|
||||
|
||||
/* a lock set or unset */
|
||||
if (ret == -1)
|
||||
{
|
||||
DEBUG(3,("lock failed at offset %d count %d op %d type %d (%s)\n",
|
||||
offset,count,op,type,strerror(errno)));
|
||||
|
||||
/* perhaps it doesn't support this sort of locking?? */
|
||||
if (errno == EINVAL)
|
||||
{
|
||||
DEBUG(3,("locking not supported? returning True\n"));
|
||||
return(True);
|
||||
}
|
||||
|
||||
return(False);
|
||||
}
|
||||
|
||||
/* everything went OK */
|
||||
DEBUG(5,("Lock call successful\n"));
|
||||
|
||||
return(True);
|
||||
#else
|
||||
return(False);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
lock a file - returning a open file descriptor or -1 on failure
|
||||
The timeout is in seconds. 0 means no timeout
|
||||
********************************************************************/
|
||||
int file_lock(char *name,int timeout)
|
||||
{
|
||||
int fd = open(name,O_RDWR|O_CREAT,0666);
|
||||
time_t t=0;
|
||||
if (fd < 0) return(-1);
|
||||
|
||||
#if HAVE_FCNTL_LOCK
|
||||
if (timeout) t = time(NULL);
|
||||
while (!timeout || (time(NULL)-t < timeout)) {
|
||||
if (fcntl_lock(fd,F_SETLK,0,1,F_WRLCK)) return(fd);
|
||||
msleep(LOCK_RETRY_TIMEOUT);
|
||||
}
|
||||
return(-1);
|
||||
#else
|
||||
return(fd);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
unlock a file locked by file_lock
|
||||
********************************************************************/
|
||||
void file_unlock(int fd)
|
||||
{
|
||||
if (fd<0) return;
|
||||
#if HAVE_FCNTL_LOCK
|
||||
fcntl_lock(fd,F_SETLK,0,1,F_UNLCK);
|
||||
#endif
|
||||
close(fd);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
determine if a file descriptor is in fact a socket
|
||||
****************************************************************************/
|
||||
@@ -2915,39 +2785,6 @@ void Abort(void )
|
||||
exit(2);
|
||||
}
|
||||
|
||||
|
||||
#ifdef REPLACE_STRLEN
|
||||
/****************************************************************************
|
||||
a replacement strlen() that returns int for solaris
|
||||
****************************************************************************/
|
||||
int Strlen(char *s)
|
||||
{
|
||||
int ret=0;
|
||||
if (!s) return(0);
|
||||
while (*s++) ret++;
|
||||
return(ret);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef NO_FTRUNCATE
|
||||
/*******************************************************************
|
||||
ftruncate for operating systems that don't have it
|
||||
********************************************************************/
|
||||
int ftruncate(int f,long l)
|
||||
{
|
||||
struct flock fl;
|
||||
|
||||
fl.l_whence = 0;
|
||||
fl.l_len = 0;
|
||||
fl.l_start = l;
|
||||
fl.l_type = F_WRLCK;
|
||||
return fcntl(f, F_FREESP, &fl);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
get my own name and IP
|
||||
****************************************************************************/
|
||||
@@ -3451,267 +3288,3 @@ char *readdirname(void *p)
|
||||
|
||||
|
||||
|
||||
#if (defined(SecureWare) && defined(SCO))
|
||||
/* This is needed due to needing the nap() function but we don't want
|
||||
to include the Xenix libraries since that will break other things...
|
||||
BTW: system call # 0x0c28 is the same as calling nap() */
|
||||
long nap(long milliseconds) {
|
||||
return syscall(0x0c28, milliseconds);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef NO_INITGROUPS
|
||||
#include <sys/types.h>
|
||||
#include <limits.h>
|
||||
#include <grp.h>
|
||||
|
||||
#ifndef NULL
|
||||
#define NULL (void *)0
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
some systems don't have an initgroups call
|
||||
****************************************************************************/
|
||||
int initgroups(char *name,gid_t id)
|
||||
{
|
||||
#ifdef NO_SETGROUPS
|
||||
/* yikes! no SETGROUPS or INITGROUPS? how can this work? */
|
||||
return(0);
|
||||
#else
|
||||
gid_t grouplst[NGROUPS_MAX];
|
||||
int i,j;
|
||||
struct group *g;
|
||||
char *gr;
|
||||
|
||||
grouplst[0] = id;
|
||||
i = 1;
|
||||
while (i < NGROUPS_MAX &&
|
||||
((g = (struct group *)getgrent()) != (struct group *)NULL))
|
||||
{
|
||||
if (g->gr_gid == id)
|
||||
continue;
|
||||
j = 0;
|
||||
gr = g->gr_mem[0];
|
||||
while (gr && (*gr != (char)NULL)) {
|
||||
if (strcmp(name,gr) == 0) {
|
||||
grouplst[i] = g->gr_gid;
|
||||
i++;
|
||||
gr = (char *)NULL;
|
||||
break;
|
||||
}
|
||||
gr = g->gr_mem[++j];
|
||||
}
|
||||
}
|
||||
endgrent();
|
||||
return(setgroups(i,grouplst));
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if WRAP_MALLOC
|
||||
|
||||
/* undo the wrapping temporarily */
|
||||
#undef malloc
|
||||
#undef realloc
|
||||
#undef free
|
||||
|
||||
/****************************************************************************
|
||||
wrapper for malloc() to catch memory errors
|
||||
****************************************************************************/
|
||||
void *malloc_wrapped(int size,char *file,int line)
|
||||
{
|
||||
#ifdef xx_old_malloc
|
||||
void *res = xx_old_malloc(size);
|
||||
#else
|
||||
void *res = malloc(size);
|
||||
#endif
|
||||
DEBUG(3,("Malloc called from %s(%d) with size=%d gave ptr=0x%X\n",
|
||||
file,line,
|
||||
size,(unsigned int)res));
|
||||
return(res);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
wrapper for realloc() to catch memory errors
|
||||
****************************************************************************/
|
||||
void *realloc_wrapped(void *ptr,int size,char *file,int line)
|
||||
{
|
||||
#ifdef xx_old_realloc
|
||||
void *res = xx_old_realloc(ptr,size);
|
||||
#else
|
||||
void *res = realloc(ptr,size);
|
||||
#endif
|
||||
DEBUG(3,("Realloc\n"));
|
||||
DEBUG(3,("free called from %s(%d) with ptr=0x%X\n",
|
||||
file,line,
|
||||
(unsigned int)ptr));
|
||||
DEBUG(3,("Malloc called from %s(%d) with size=%d gave ptr=0x%X\n",
|
||||
file,line,
|
||||
size,(unsigned int)res));
|
||||
return(res);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
wrapper for free() to catch memory errors
|
||||
****************************************************************************/
|
||||
void free_wrapped(void *ptr,char *file,int line)
|
||||
{
|
||||
#ifdef xx_old_free
|
||||
xx_old_free(ptr);
|
||||
#else
|
||||
free(ptr);
|
||||
#endif
|
||||
DEBUG(3,("free called from %s(%d) with ptr=0x%X\n",
|
||||
file,line,(unsigned int)ptr));
|
||||
return;
|
||||
}
|
||||
|
||||
/* and re-do the define for spots lower in this file */
|
||||
#define malloc(size) malloc_wrapped(size,__FILE__,__LINE__)
|
||||
#define realloc(ptr,size) realloc_wrapped(ptr,size,__FILE__,__LINE__)
|
||||
#define free(ptr) free_wrapped(ptr,__FILE__,__LINE__)
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef REPLACE_STRSTR
|
||||
/****************************************************************************
|
||||
Mips version of strstr doesn't seem to work correctly.
|
||||
There is a #define in includes.h to redirect calls to this function.
|
||||
****************************************************************************/
|
||||
char *Strstr(char *s, char *p)
|
||||
{
|
||||
int len = strlen(p);
|
||||
|
||||
while ( *s != '\0' ) {
|
||||
if ( strncmp(s, p, len) == 0 )
|
||||
return s;
|
||||
s++;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
#endif /* REPLACE_STRSTR */
|
||||
|
||||
|
||||
#ifdef REPLACE_MKTIME
|
||||
/*******************************************************************
|
||||
a mktime() replacement for those who don't have it - contributed by
|
||||
C.A. Lademann <cal@zls.com>
|
||||
********************************************************************/
|
||||
#define MINUTE 60
|
||||
#define HOUR 60*MINUTE
|
||||
#define DAY 24*HOUR
|
||||
#define YEAR 365*DAY
|
||||
time_t Mktime(struct tm *t)
|
||||
{
|
||||
struct tm *u;
|
||||
time_t epoch = 0;
|
||||
int mon [] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
|
||||
y, m, i;
|
||||
|
||||
if(t->tm_year < 70)
|
||||
return((time_t)-1);
|
||||
|
||||
epoch = (t->tm_year - 70) * YEAR +
|
||||
(t->tm_year / 4 - 70 / 4 - t->tm_year / 100) * DAY;
|
||||
|
||||
y = t->tm_year;
|
||||
m = 0;
|
||||
|
||||
for(i = 0; i < t->tm_mon; i++) {
|
||||
epoch += mon [m] * DAY;
|
||||
if(m == 1 && y % 4 == 0 && (y % 100 != 0 || y % 400 == 0))
|
||||
epoch += DAY;
|
||||
|
||||
if(++m > 11) {
|
||||
m = 0;
|
||||
y++;
|
||||
}
|
||||
}
|
||||
|
||||
epoch += (t->tm_mday - 1) * DAY;
|
||||
epoch += t->tm_hour * HOUR + t->tm_min * MINUTE + t->tm_sec;
|
||||
|
||||
if((u = localtime(&epoch)) != NULL) {
|
||||
t->tm_sec = u->tm_sec;
|
||||
t->tm_min = u->tm_min;
|
||||
t->tm_hour = u->tm_hour;
|
||||
t->tm_mday = u->tm_mday;
|
||||
t->tm_mon = u->tm_mon;
|
||||
t->tm_year = u->tm_year;
|
||||
t->tm_wday = u->tm_wday;
|
||||
t->tm_yday = u->tm_yday;
|
||||
t->tm_isdst = u->tm_isdst;
|
||||
#ifndef NO_TM_NAME
|
||||
memcpy(t->tm_name, u->tm_name, LTZNMAX);
|
||||
#endif
|
||||
}
|
||||
|
||||
return(epoch);
|
||||
}
|
||||
#endif /* REPLACE_MKTIME */
|
||||
|
||||
|
||||
|
||||
#ifdef REPLACE_RENAME
|
||||
/* Rename a file. (from libiberty in GNU binutils) */
|
||||
int rename (zfrom, zto)
|
||||
const char *zfrom;
|
||||
const char *zto;
|
||||
{
|
||||
if (link (zfrom, zto) < 0)
|
||||
{
|
||||
if (errno != EEXIST)
|
||||
return -1;
|
||||
if (unlink (zto) < 0
|
||||
|| link (zfrom, zto) < 0)
|
||||
return -1;
|
||||
}
|
||||
return unlink (zfrom);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef REPLACE_INNETGR
|
||||
/*
|
||||
* Search for a match in a netgroup. This replaces it on broken systems.
|
||||
*/
|
||||
int InNetGr(char *group,char *host,char *user,char *dom)
|
||||
{
|
||||
char *hst, *usr, *dm;
|
||||
|
||||
setnetgrent(group);
|
||||
while (getnetgrent(&hst, &usr, &dm))
|
||||
if (((host == 0) || (hst == 0) || !strcmp(host, hst)) &&
|
||||
((user == 0) || (usr == 0) || !strcmp(user, usr)) &&
|
||||
((dom == 0) || (dm == 0) || !strcmp(dom, dm))) {
|
||||
endnetgrent();
|
||||
return (1);
|
||||
}
|
||||
endnetgrent();
|
||||
return (0);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if WRAP_MEMCPY
|
||||
#undef memcpy
|
||||
/*******************************************************************
|
||||
a wrapper around memcpy for diagnostic purposes
|
||||
********************************************************************/
|
||||
void *memcpy_wrapped(void *d,void *s,int l,char *fname,int line)
|
||||
{
|
||||
if (l>64 && (((int)d)%4) != (((int)s)%4))
|
||||
DEBUG(4,("Misaligned memcpy(0x%X,0x%X,%d) at %s(%d)\n",d,s,l,fname,line));
|
||||
#ifdef xx_old_memcpy
|
||||
return(xx_old_memcpy(d,s,l));
|
||||
#else
|
||||
return(memcpy(d,s,l));
|
||||
#endif
|
||||
}
|
||||
#define memcpy(d,s,l) memcpy_wrapped(d,s,l,__FILE__,__LINE__)
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user