mirror of
https://github.com/samba-team/samba.git
synced 2024-12-24 21:34:56 +03:00
87325d9c6c
(This used to be commit 32bd713712
)
296 lines
6.9 KiB
C
296 lines
6.9 KiB
C
/*
|
|
Unix SMB/Netbios implementation.
|
|
Version 1.9.
|
|
replacement routines for broken systems
|
|
Copyright (C) Andrew Tridgell 1992-1998
|
|
|
|
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 2 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, write to the Free Software
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
#include "includes.h"
|
|
|
|
extern int DEBUGLEVEL;
|
|
|
|
|
|
void replace_dummy(void)
|
|
{}
|
|
|
|
|
|
#ifndef HAVE_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
|
|
|
|
|
|
#ifndef HAVE_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;
|
|
}
|
|
|
|
return(epoch);
|
|
}
|
|
#endif /* !HAVE_MKTIME */
|
|
|
|
|
|
|
|
#ifndef HAVE_RENAME
|
|
/* Rename a file. (from libiberty in GNU binutils) */
|
|
int rename(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
|
|
|
|
|
|
#ifndef HAVE_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
|
|
|
|
|
|
|
|
#ifndef HAVE_INITGROUPS
|
|
/****************************************************************************
|
|
some systems don't have an initgroups call
|
|
****************************************************************************/
|
|
int initgroups(char *name,gid_t id)
|
|
{
|
|
#ifndef HAVE_SETGROUPS
|
|
static int done;
|
|
if (!done) {
|
|
DEBUG(1,("WARNING: running without setgroups\n"));
|
|
done=1;
|
|
}
|
|
/* 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 (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
|
|
|
|
|
|
#ifndef HAVE_MEMMOVE
|
|
/*******************************************************************
|
|
safely copies memory, ensuring no overlap problems.
|
|
this is only used if the machine does not have it's own memmove().
|
|
this is not the fastest algorithm in town, but it will do for our
|
|
needs.
|
|
********************************************************************/
|
|
void *memmove(void *dest,const void *src,int size)
|
|
{
|
|
unsigned long d,s;
|
|
int i;
|
|
if (dest==src || !size) return(dest);
|
|
|
|
d = (unsigned long)dest;
|
|
s = (unsigned long)src;
|
|
|
|
if ((d >= (s+size)) || (s >= (d+size))) {
|
|
/* no overlap */
|
|
memcpy(dest,src,size);
|
|
return(dest);
|
|
}
|
|
|
|
if (d < s) {
|
|
/* we can forward copy */
|
|
if (s-d >= sizeof(int) &&
|
|
!(s%sizeof(int)) &&
|
|
!(d%sizeof(int)) &&
|
|
!(size%sizeof(int))) {
|
|
/* do it all as words */
|
|
int *idest = (int *)dest;
|
|
int *isrc = (int *)src;
|
|
size /= sizeof(int);
|
|
for (i=0;i<size;i++) idest[i] = isrc[i];
|
|
} else {
|
|
/* simplest */
|
|
char *cdest = (char *)dest;
|
|
char *csrc = (char *)src;
|
|
for (i=0;i<size;i++) cdest[i] = csrc[i];
|
|
}
|
|
} else {
|
|
/* must backward copy */
|
|
if (d-s >= sizeof(int) &&
|
|
!(s%sizeof(int)) &&
|
|
!(d%sizeof(int)) &&
|
|
!(size%sizeof(int))) {
|
|
/* do it all as words */
|
|
int *idest = (int *)dest;
|
|
int *isrc = (int *)src;
|
|
size /= sizeof(int);
|
|
for (i=size-1;i>=0;i--) idest[i] = isrc[i];
|
|
} else {
|
|
/* simplest */
|
|
char *cdest = (char *)dest;
|
|
char *csrc = (char *)src;
|
|
for (i=size-1;i>=0;i--) cdest[i] = csrc[i];
|
|
}
|
|
}
|
|
return(dest);
|
|
}
|
|
#endif
|
|
|
|
#ifndef HAVE_STRDUP
|
|
/****************************************************************************
|
|
duplicate a string
|
|
****************************************************************************/
|
|
char *strdup(const char *s)
|
|
{
|
|
int len;
|
|
char *ret;
|
|
|
|
if (!s) return(NULL);
|
|
|
|
len = strlen(s)+1;
|
|
ret = (char *)malloc(len);
|
|
if (!ret) return(NULL);
|
|
memcpy(ret,s,len);
|
|
return(ret);
|
|
}
|
|
#endif
|
|
|
|
#ifdef REPLACE_INET_NTOA
|
|
char *rep_inet_ntoa(struct in_addr ip)
|
|
{
|
|
unsigned char *p = (unsigned char *)&ip.s_addr;
|
|
static char buf[18];
|
|
#if WORDS_BIGENDIAN
|
|
slprintf(buf, 17, "%d.%d.%d.%d",
|
|
(int)p[0], (int)p[1], (int)p[2], (int)p[3]);
|
|
#else
|
|
slprintf(buf, 17, "%d.%d.%d.%d",
|
|
(int)p[3], (int)p[2], (int)p[1], (int)p[0]);
|
|
#endif
|
|
return buf;
|
|
}
|
|
#endif
|