return if some data has arrived on one of the file descriptors
return -1 means error
********************************************************************/
-#ifdef NO_SELECT
+#ifndef HAVE_SELECT
static int pollfd(int fd)
{
int r=0;
return(r);
}
-int sys_select(fd_set *fds,struct timeval *tval)
+int sys_select(int maxfd, fd_set *fds,struct timeval *tval)
{
fd_set fds2;
int counter=0;
FD_ZERO(&fds2);
while (1)
- {
- int i;
- for (i=0;i<255;i++) {
- if (FD_ISSET(i,fds) && pollfd(i)>0) {
- found++;
- FD_SET(i,&fds2);
- }
+ {
+ int i;
+ for (i=0;i<maxfd;i++) {
+ if (FD_ISSET(i,fds) && pollfd(i)>0) {
+ found++;
+ FD_SET(i,&fds2);
}
+ }
- if (found) {
- memcpy((void *)fds,(void *)&fds2,sizeof(fds2));
- return(found);
- }
+ if (found) {
+ memcpy((void *)fds,(void *)&fds2,sizeof(fds2));
+ return(found);
+ }
- if (tval && tval->tv_sec < counter) return(0);
+ if (tval && tval->tv_sec < counter) return(0);
sleep(1);
counter++;
- }
+ }
}
-#else
-int sys_select(fd_set *fds,struct timeval *tval)
+#else /* !NO_SELECT */
+int sys_select(int maxfd, fd_set *fds,struct timeval *tval)
{
+#ifdef USE_POLL
+ struct pollfd pfd[256];
+ int i;
+ int maxpoll;
+ int timeout;
+ int pollrtn;
+
+ maxpoll = 0;
+ for( i = 0; i < maxfd; i++) {
+ if(FD_ISSET(i,fds)) {
+ struct pollfd *pfdp = &pfd[maxpoll++];
+ pfdp->fd = i;
+ pfdp->events = POLLIN;
+ pfdp->revents = 0;
+ }
+ }
+
+ timeout = (tval != NULL) ? (tval->tv_sec * 1000) + (tval->tv_usec/1000) :
+ -1;
+ errno = 0;
+ do {
+ pollrtn = poll( &pfd[0], maxpoll, timeout);
+ } while (pollrtn<0 && errno == EINTR);
+
+ FD_ZERO(fds);
+
+ for( i = 0; i < maxpoll; i++)
+ if( pfd[i].revents & POLLIN )
+ FD_SET(pfd[i].fd,fds);
+
+ return pollrtn;
+#else /* USE_POLL */
+
struct timeval t2;
int selrtn;
do {
if (tval) memcpy((void *)&t2,(void *)tval,sizeof(t2));
errno = 0;
- selrtn = select(255,SELECT_CAST fds,NULL,NULL,tval?&t2:NULL);
+ selrtn = select(maxfd,SELECT_CAST fds,NULL,NULL,tval?&t2:NULL);
} while (selrtn<0 && errno == EINTR);
return(selrtn);
}
+#endif /* USE_POLL */
+#endif /* NO_SELECT */
+
+/*******************************************************************
+A stat() wrapper that will deal with 64 bit filesizes.
+********************************************************************/
+
+int sys_stat(char *fname,SMB_STRUCT_STAT *sbuf)
+{
+#if defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
+ return stat64(fname, sbuf);
+#else
+ return stat(fname, sbuf);
+#endif
+}
+
+/*******************************************************************
+ An fstat() wrapper that will deal with 64 bit filesizes.
+********************************************************************/
+
+int sys_fstat(int fd,SMB_STRUCT_STAT *sbuf)
+{
+#if defined(HAVE_OFF64_T) && defined(HAVE_FSTAT64)
+ return fstat64(fd, sbuf);
+#else
+ return fstat(fd, sbuf);
+#endif
+}
+
+/*******************************************************************
+ An lstat() wrapper that will deal with 64 bit filesizes.
+********************************************************************/
+
+int sys_lstat(char *fname,SMB_STRUCT_STAT *sbuf)
+{
+#if defined(HAVE_OFF64_T) && defined(HAVE_LSTAT64)
+ return lstat64(fname, sbuf);
+#else
+ return lstat(fname, sbuf);
#endif
+}
+/*******************************************************************
+ An ftruncate() wrapper that will deal with 64 bit filesizes.
+********************************************************************/
+
+int sys_ftruncate(int fd, SMB_OFF_T offset)
+{
+#if defined(HAVE_OFF64_T) && defined(HAVE_FTRUNCATE64)
+ return ftruncate64(fd, offset);
+#else
+ return ftruncate(fd, offset);
+#endif
+}
+
+/*******************************************************************
+ An lseek() wrapper that will deal with 64 bit filesizes.
+********************************************************************/
+
+int sys_lseek(int fd, SMB_OFF_T offset, int whence)
+{
+#if defined(HAVE_OFF64_T) && defined(HAVE_LSEEK64)
+ return lseek64(fd, offset, whence);
+#else
+ return lseek(fd, offset, whence);
+#endif
+}
/*******************************************************************
-just a unlink wrapper
+just a unlink wrapper that calls dos_to_unix.
********************************************************************/
-int sys_unlink(char *fname)
+int dos_unlink(char *fname)
{
return(unlink(dos_to_unix(fname,False)));
}
/*******************************************************************
-a simple open() wrapper
+a simple open() wrapper that calls dos_to_unix.
********************************************************************/
-int sys_open(char *fname,int flags,int mode)
+int dos_open(char *fname,int flags,int mode)
{
return(open(dos_to_unix(fname,False),flags,mode));
}
/*******************************************************************
-a simple opendir() wrapper
+a simple opendir() wrapper that calls dos_to_unix
********************************************************************/
-DIR *sys_opendir(char *dname)
+DIR *dos_opendir(char *dname)
{
- return(opendir(dos_to_unix(dname,False)));
+ return(opendir(dos_to_unix(dname,False)));
}
-
/*******************************************************************
-and a stat() wrapper
+and a stat() wrapper that calls dos_to_unix.
********************************************************************/
-int sys_stat(char *fname,struct stat *sbuf)
+int dos_stat(char *fname,SMB_STRUCT_STAT *sbuf)
{
- return(stat(dos_to_unix(fname,False),sbuf));
+ return(sys_stat(dos_to_unix(fname,False),sbuf));
}
/*******************************************************************
********************************************************************/
int sys_waitpid(pid_t pid,int *status,int options)
{
-#ifdef USE_WAITPID
+#ifdef HAVE_WAITPID
return waitpid(pid,status,options);
-#else /* USE_WAITPID */
+#else /* HAVE_WAITPID */
return wait4(pid, status, options, NULL);
-#endif /* USE_WAITPID */
+#endif /* HAVE_WAITPID */
}
/*******************************************************************
-don't forget lstat()
+don't forget lstat() that calls dos_to_unix.
********************************************************************/
-int sys_lstat(char *fname,struct stat *sbuf)
+int dos_lstat(char *fname,SMB_STRUCT_STAT *sbuf)
{
- return(lstat(dos_to_unix(fname,False),sbuf));
+ return(sys_lstat(dos_to_unix(fname,False),sbuf));
}
-
/*******************************************************************
-mkdir() gets a wrapper
+mkdir() gets a wrapper that calls dos_to_unix.
********************************************************************/
-int sys_mkdir(char *dname,int mode)
+int dos_mkdir(char *dname,int mode)
{
return(mkdir(dos_to_unix(dname,False),mode));
}
-
/*******************************************************************
-do does rmdir()
+do does rmdir() - call dos_to_unix
********************************************************************/
-int sys_rmdir(char *dname)
+int dos_rmdir(char *dname)
{
return(rmdir(dos_to_unix(dname,False)));
}
-
/*******************************************************************
-I almost forgot chdir()
+I almost forgot chdir() - call dos_to_unix.
********************************************************************/
-int sys_chdir(char *dname)
+int dos_chdir(char *dname)
{
return(chdir(dos_to_unix(dname,False)));
}
-
/*******************************************************************
-now for utime()
+now for utime() - call dos_to_unix.
********************************************************************/
-int sys_utime(char *fname,struct utimbuf *times)
+int dos_utime(char *fname,struct utimbuf *times)
{
/* if the modtime is 0 or -1 then ignore the call and
return success */
static int copy_reg(char *source, const char *dest)
{
- struct stat source_stats;
+ SMB_STRUCT_STAT source_stats;
int ifd;
int ofd;
char *buf;
int len; /* Number of bytes read into `buf'. */
- lstat (source, &source_stats);
+ sys_lstat (source, &source_stats);
if (!S_ISREG (source_stats.st_mode))
- {
- return 1;
- }
+ return 1;
if (unlink (dest) && errno != ENOENT)
- {
- return 1;
- }
+ return 1;
if((ifd = open (source, O_RDONLY, 0)) < 0)
- {
- return 1;
- }
+ return 1;
+
if((ofd = open (dest, O_WRONLY | O_CREAT | O_TRUNC, 0600)) < 0 )
- {
- close (ifd);
- return 1;
- }
+ {
+ close (ifd);
+ return 1;
+ }
if((buf = malloc( COPYBUF_SIZE )) == NULL)
- {
- close (ifd);
- close (ofd);
- unlink (dest);
- return 1;
- }
+ {
+ close (ifd);
+ close (ofd);
+ unlink (dest);
+ return 1;
+ }
while ((len = read(ifd, buf, COPYBUF_SIZE)) > 0)
- {
- if (write_data(ofd, buf, len) < 0)
- {
- close (ifd);
- close (ofd);
- unlink (dest);
- free(buf);
- return 1;
- }
- }
- free(buf);
- if (len < 0)
+ {
+ if (write_data(ofd, buf, len) < 0)
{
close (ifd);
close (ofd);
unlink (dest);
+ free(buf);
return 1;
}
+ }
+ free(buf);
+ if (len < 0)
+ {
+ close (ifd);
+ close (ofd);
+ unlink (dest);
+ return 1;
+ }
if (close (ifd) < 0)
- {
- close (ofd);
- return 1;
- }
+ {
+ close (ofd);
+ return 1;
+ }
if (close (ofd) < 0)
- {
- return 1;
- }
+ return 1;
/* chown turns off set[ug]id bits for non-root,
so do the chmod last. */
tv.actime = source_stats.st_atime;
tv.modtime = source_stats.st_mtime;
if (utime (dest, &tv))
- {
- return 1;
- }
+ return 1;
}
/* Try to preserve ownership. For non-root it might fail, but that's ok.
But root probably wants to know, e.g. if NFS disallows it. */
if (chown (dest, source_stats.st_uid, source_stats.st_gid)
&& (errno != EPERM))
- {
- return 1;
- }
+ return 1;
if (chmod (dest, source_stats.st_mode & 07777))
- {
- return 1;
- }
+ return 1;
+
unlink (source);
return 0;
}
/*******************************************************************
-for rename()
+for rename() - call dos_to_unix.
********************************************************************/
-int sys_rename(char *from, char *to)
+int dos_rename(char *from, char *to)
{
int rcode;
pstring zfrom, zto;
rcode = rename (zfrom, zto);
if (errno == EXDEV)
- {
- /* Rename across filesystems needed. */
- rcode = copy_reg (zfrom, zto);
- }
+ {
+ /* Rename across filesystems needed. */
+ rcode = copy_reg (zfrom, zto);
+ }
return rcode;
}
/*******************************************************************
-for chmod
+for chmod - call dos_to_unix.
********************************************************************/
-int sys_chmod(char *fname,int mode)
+int dos_chmod(char *fname,int mode)
{
return(chmod(dos_to_unix(fname,False),mode));
}
/*******************************************************************
-for getwd
+for getwd - takes a UNIX directory name and returns the name
+in dos format.
********************************************************************/
-char *sys_getwd(char *s)
+char *dos_getwd(char *s)
{
- char *wd;
-#ifdef USE_GETCWD
- wd = (char *) getcwd (s, sizeof (pstring));
+ char *wd;
+#ifdef HAVE_GETCWD
+ wd = (char *)getcwd(s, sizeof (pstring));
#else
- wd = (char *) getwd (s);
+ wd = (char *)getwd(s);
#endif
- if (wd)
- unix_to_dos (wd, True);
- return wd;
+ if (wd)
+ unix_to_dos(wd, True);
+ return wd;
}
/*******************************************************************
********************************************************************/
int sys_chown(char *fname,int uid,int gid)
{
-#ifdef NO_CHOWN
- DEBUG(1,("Warning - chown(%s,%d,%d) not done\n",fname,uid,gid));
+#ifndef HAVE_CHOWN
+ static int done;
+ if (!done) {
+ DEBUG(1,("WARNING: no chown!\n"));
+ done=1;
+ }
#else
- return(chown(fname,uid,gid));
+ return(chown(fname,uid,gid));
#endif
}
********************************************************************/
int sys_chroot(char *dname)
{
-#ifdef NO_CHROOT
- DEBUG(1,("Warning - chroot(%s) not done\n",dname));
+#ifndef HAVE_CHROOT
+ static int done;
+ if (!done) {
+ DEBUG(1,("WARNING: no chroot!\n"));
+ done=1;
+ }
#else
- return(chroot(dname));
+ return(chroot(dname));
#endif
}
if((strlen(name) + strlen(domain)) >= sizeof(query))
return(gethostbyname(name));
- sprintf(query, "%s%s", name, domain);
+ slprintf(query, sizeof(query)-1, "%s%s", name, domain);
return(gethostbyname(query));
#else /* REDUCE_ROOT_DNS_LOOKUPS */
return(gethostbyname(name));
#endif /* REDUCE_ROOT_DNS_LOOKUPS */
}
-
git.samba.org / ira / wip.git / blobdiff