Ok - this is the 64 bit widening check in. It changes the configure
[ira/wip.git] / source3 / lib / system.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    Samba system utilities
5    Copyright (C) Andrew Tridgell 1992-1998
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include "includes.h"
23
24 extern int DEBUGLEVEL;
25
26 /*
27    The idea is that this file will eventually have wrappers around all
28    important system calls in samba. The aims are:
29
30    - to enable easier porting by putting OS dependent stuff in here
31
32    - to allow for hooks into other "pseudo-filesystems"
33
34    - to allow easier integration of things like the japanese extensions
35
36    - to support the philosophy of Samba to expose the features of
37      the OS within the SMB model. In general whatever file/printer/variable
38      expansions/etc make sense to the OS should be acceptable to Samba.
39 */
40
41
42 /*******************************************************************
43 this replaces the normal select() system call
44 return if some data has arrived on one of the file descriptors
45 return -1 means error
46 ********************************************************************/
47 #ifndef HAVE_SELECT
48 static int pollfd(int fd)
49 {
50   int     r=0;
51
52 #ifdef HAS_RDCHK
53   r = rdchk(fd);
54 #elif defined(TCRDCHK)
55   (void)ioctl(fd, TCRDCHK, &r);
56 #else
57   (void)ioctl(fd, FIONREAD, &r);
58 #endif
59
60   return(r);
61 }
62
63 int sys_select(int maxfd, fd_set *fds,struct timeval *tval)
64 {
65   fd_set fds2;
66   int counter=0;
67   int found=0;
68
69   FD_ZERO(&fds2);
70
71   while (1) 
72   {
73     int i;
74     for (i=0;i<maxfd;i++) {
75       if (FD_ISSET(i,fds) && pollfd(i)>0) {
76         found++;
77         FD_SET(i,&fds2);
78       }
79     }
80
81     if (found) {
82       memcpy((void *)fds,(void *)&fds2,sizeof(fds2));
83       return(found);
84     }
85       
86     if (tval && tval->tv_sec < counter) return(0);
87       sleep(1);
88       counter++;
89   }
90 }
91
92 #else /* !NO_SELECT */
93 int sys_select(int maxfd, fd_set *fds,struct timeval *tval)
94 {
95 #ifdef USE_POLL
96   struct pollfd pfd[256];
97   int i;
98   int maxpoll;
99   int timeout;
100   int pollrtn;
101
102   maxpoll = 0;
103   for( i = 0; i < maxfd; i++) {
104     if(FD_ISSET(i,fds)) {
105       struct pollfd *pfdp = &pfd[maxpoll++];
106       pfdp->fd = i;
107       pfdp->events = POLLIN;
108       pfdp->revents = 0;
109     }
110   }
111
112   timeout = (tval != NULL) ? (tval->tv_sec * 1000) + (tval->tv_usec/1000) :
113                 -1;
114   errno = 0;
115   do {
116     pollrtn = poll( &pfd[0], maxpoll, timeout);
117   } while (pollrtn<0 && errno == EINTR);
118
119   FD_ZERO(fds);
120
121   for( i = 0; i < maxpoll; i++)
122     if( pfd[i].revents & POLLIN )
123       FD_SET(pfd[i].fd,fds);
124
125   return pollrtn;
126 #else /* USE_POLL */
127
128   struct timeval t2;
129   int selrtn;
130
131   do {
132     if (tval) memcpy((void *)&t2,(void *)tval,sizeof(t2));
133     errno = 0;
134     selrtn = select(maxfd,SELECT_CAST fds,NULL,NULL,tval?&t2:NULL);
135   } while (selrtn<0 && errno == EINTR);
136
137   return(selrtn);
138 }
139 #endif /* USE_POLL */
140 #endif /* NO_SELECT */
141
142 /*******************************************************************
143 A stat() wrapper that will deal with 64 bit filesizes.
144 ********************************************************************/
145
146 int sys_stat(char *fname,SMB_STRUCT_STAT *sbuf)
147 {
148 #if defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
149   return stat64(fname, sbuf);
150 #else
151   return stat(fname, sbuf);
152 #endif
153 }
154
155 /*******************************************************************
156  An fstat() wrapper that will deal with 64 bit filesizes.
157 ********************************************************************/
158
159 int sys_fstat(int fd,SMB_STRUCT_STAT *sbuf)
160 {
161 #if defined(HAVE_OFF64_T) && defined(HAVE_FSTAT64)
162   return fstat64(fd, sbuf);
163 #else
164   return fstat(fd, sbuf);
165 #endif
166 }
167
168 /*******************************************************************
169  An lstat() wrapper that will deal with 64 bit filesizes.
170 ********************************************************************/
171
172 int sys_lstat(char *fname,SMB_STRUCT_STAT *sbuf)
173 {
174 #if defined(HAVE_OFF64_T) && defined(HAVE_LSTAT64)
175   return lstat64(fname, sbuf);
176 #else
177   return lstat(fname, sbuf);
178 #endif
179 }
180
181 /*******************************************************************
182  An ftruncate() wrapper that will deal with 64 bit filesizes.
183 ********************************************************************/
184
185 int sys_ftruncate(int fd, SMB_OFF_T offset)
186 {
187 #if defined(HAVE_OFF64_T) && defined(HAVE_FTRUNCATE64)
188   return ftruncate64(fd, offset);
189 #else
190   return ftruncate(fd, offset);
191 #endif
192 }
193
194 /*******************************************************************
195  An lseek() wrapper that will deal with 64 bit filesizes.
196 ********************************************************************/
197
198 int sys_lseek(int fd, SMB_OFF_T offset, int whence)
199 {
200 #if defined(HAVE_OFF64_T) && defined(HAVE_LSEEK64)
201   return lseek64(fd, offset, whence);
202 #else
203   return lseek(fd, offset, whence);
204 #endif
205 }
206
207 /*******************************************************************
208 just a unlink wrapper that calls dos_to_unix.
209 ********************************************************************/
210 int dos_unlink(char *fname)
211 {
212   return(unlink(dos_to_unix(fname,False)));
213 }
214
215
216 /*******************************************************************
217 a simple open() wrapper that calls dos_to_unix.
218 ********************************************************************/
219 int dos_open(char *fname,int flags,int mode)
220 {
221   return(open(dos_to_unix(fname,False),flags,mode));
222 }
223
224
225 /*******************************************************************
226 a simple opendir() wrapper that calls dos_to_unix
227 ********************************************************************/
228 DIR *dos_opendir(char *dname)
229 {
230         return(opendir(dos_to_unix(dname,False)));
231 }
232
233 /*******************************************************************
234 and a stat() wrapper that calls dos_to_unix.
235 ********************************************************************/
236 int dos_stat(char *fname,SMB_STRUCT_STAT *sbuf)
237 {
238   return(sys_stat(dos_to_unix(fname,False),sbuf));
239 }
240
241 /*******************************************************************
242 The wait() calls vary between systems
243 ********************************************************************/
244 int sys_waitpid(pid_t pid,int *status,int options)
245 {
246 #ifdef HAVE_WAITPID
247   return waitpid(pid,status,options);
248 #else /* HAVE_WAITPID */
249   return wait4(pid, status, options, NULL);
250 #endif /* HAVE_WAITPID */
251 }
252
253 /*******************************************************************
254 don't forget lstat() that calls dos_to_unix.
255 ********************************************************************/
256 int dos_lstat(char *fname,SMB_STRUCT_STAT *sbuf)
257 {
258   return(sys_lstat(dos_to_unix(fname,False),sbuf));
259 }
260
261 /*******************************************************************
262 mkdir() gets a wrapper that calls dos_to_unix.
263 ********************************************************************/
264 int dos_mkdir(char *dname,int mode)
265 {
266   return(mkdir(dos_to_unix(dname,False),mode));
267 }
268
269 /*******************************************************************
270 do does rmdir() - call dos_to_unix
271 ********************************************************************/
272 int dos_rmdir(char *dname)
273 {
274   return(rmdir(dos_to_unix(dname,False)));
275 }
276
277 /*******************************************************************
278 I almost forgot chdir() - call dos_to_unix.
279 ********************************************************************/
280 int dos_chdir(char *dname)
281 {
282   return(chdir(dos_to_unix(dname,False)));
283 }
284
285 /*******************************************************************
286 now for utime() - call dos_to_unix.
287 ********************************************************************/
288 int dos_utime(char *fname,struct utimbuf *times)
289 {
290   /* if the modtime is 0 or -1 then ignore the call and
291      return success */
292   if (times->modtime == (time_t)0 || times->modtime == (time_t)-1)
293     return 0;
294   
295   /* if the access time is 0 or -1 then set it to the modtime */
296   if (times->actime == (time_t)0 || times->actime == (time_t)-1)
297     times->actime = times->modtime;
298    
299   return(utime(dos_to_unix(fname,False),times));
300 }
301
302 /*********************************************************
303 for rename across filesystems Patch from Warren Birnbaum 
304 <warrenb@hpcvscdp.cv.hp.com>
305 **********************************************************/
306
307 static int copy_reg(char *source, const char *dest)
308 {
309   SMB_STRUCT_STAT source_stats;
310   int ifd;
311   int ofd;
312   char *buf;
313   int len;                      /* Number of bytes read into `buf'. */
314
315   sys_lstat (source, &source_stats);
316   if (!S_ISREG (source_stats.st_mode))
317     return 1;
318
319   if (unlink (dest) && errno != ENOENT)
320     return 1;
321
322   if((ifd = open (source, O_RDONLY, 0)) < 0)
323     return 1;
324
325   if((ofd = open (dest, O_WRONLY | O_CREAT | O_TRUNC, 0600)) < 0 )
326   {
327     close (ifd);
328     return 1;
329   }
330
331   if((buf = malloc( COPYBUF_SIZE )) == NULL)
332   {
333     close (ifd);  
334     close (ofd);  
335     unlink (dest);
336     return 1;
337   }
338
339   while ((len = read(ifd, buf, COPYBUF_SIZE)) > 0)
340   {
341     if (write_data(ofd, buf, len) < 0)
342     {
343       close (ifd);
344       close (ofd);
345       unlink (dest);
346       free(buf);
347       return 1;
348     }
349   }
350   free(buf);
351   if (len < 0)
352   {
353     close (ifd);
354     close (ofd);
355     unlink (dest);
356     return 1;
357   }
358
359   if (close (ifd) < 0)
360   {
361     close (ofd);
362     return 1;
363   }
364   if (close (ofd) < 0)
365     return 1;
366
367   /* chown turns off set[ug]id bits for non-root,
368      so do the chmod last.  */
369
370   /* Try to copy the old file's modtime and access time.  */
371   {
372     struct utimbuf tv;
373
374     tv.actime = source_stats.st_atime;
375     tv.modtime = source_stats.st_mtime;
376     if (utime (dest, &tv))
377       return 1;
378   }
379
380   /* Try to preserve ownership.  For non-root it might fail, but that's ok.
381      But root probably wants to know, e.g. if NFS disallows it.  */
382   if (chown (dest, source_stats.st_uid, source_stats.st_gid)
383       && (errno != EPERM))
384     return 1;
385
386   if (chmod (dest, source_stats.st_mode & 07777))
387     return 1;
388
389   unlink (source);
390   return 0;
391 }
392
393 /*******************************************************************
394 for rename() - call dos_to_unix.
395 ********************************************************************/
396 int dos_rename(char *from, char *to)
397 {
398     int rcode;  
399     pstring zfrom, zto;
400
401     pstrcpy (zfrom, dos_to_unix (from, False));
402     pstrcpy (zto, dos_to_unix (to, False));
403     rcode = rename (zfrom, zto);
404
405     if (errno == EXDEV) 
406     {
407       /* Rename across filesystems needed. */
408       rcode = copy_reg (zfrom, zto);        
409     }
410     return rcode;
411 }
412
413 /*******************************************************************
414 for chmod - call dos_to_unix.
415 ********************************************************************/
416 int dos_chmod(char *fname,int mode)
417 {
418   return(chmod(dos_to_unix(fname,False),mode));
419 }
420
421 /*******************************************************************
422 for getwd - takes a UNIX directory name and returns the name
423 in dos format.
424 ********************************************************************/
425 char *dos_getwd(char *s)
426 {
427         char *wd;
428 #ifdef HAVE_GETCWD
429         wd = (char *)getcwd(s, sizeof (pstring));
430 #else
431         wd = (char *)getwd(s);
432 #endif
433         if (wd)
434                 unix_to_dos(wd, True);
435         return wd;
436 }
437
438 /*******************************************************************
439 chown isn't used much but OS/2 doesn't have it
440 ********************************************************************/
441 int sys_chown(char *fname,int uid,int gid)
442 {
443 #ifndef HAVE_CHOWN
444         static int done;
445         if (!done) {
446                 DEBUG(1,("WARNING: no chown!\n"));
447                 done=1;
448         }
449 #else
450         return(chown(fname,uid,gid));
451 #endif
452 }
453
454 /*******************************************************************
455 os/2 also doesn't have chroot
456 ********************************************************************/
457 int sys_chroot(char *dname)
458 {
459 #ifndef HAVE_CHROOT
460         static int done;
461         if (!done) {
462                 DEBUG(1,("WARNING: no chroot!\n"));
463                 done=1;
464         }
465 #else
466         return(chroot(dname));
467 #endif
468 }
469
470 /**************************************************************************
471 A wrapper for gethostbyname() that tries avoids looking up hostnames 
472 in the root domain, which can cause dial-on-demand links to come up for no
473 apparent reason.
474 ****************************************************************************/
475 struct hostent *sys_gethostbyname(char *name)
476 {
477 #ifdef REDUCE_ROOT_DNS_LOOKUPS
478   char query[256], hostname[256];
479   char *domain;
480
481   /* Does this name have any dots in it? If so, make no change */
482
483   if (strchr(name, '.'))
484     return(gethostbyname(name));
485
486   /* Get my hostname, which should have domain name 
487      attached. If not, just do the gethostname on the
488      original string. 
489   */
490
491   gethostname(hostname, sizeof(hostname) - 1);
492   hostname[sizeof(hostname) - 1] = 0;
493   if ((domain = strchr(hostname, '.')) == NULL)
494     return(gethostbyname(name));
495
496   /* Attach domain name to query and do modified query.
497      If names too large, just do gethostname on the
498      original string.
499   */
500
501   if((strlen(name) + strlen(domain)) >= sizeof(query))
502     return(gethostbyname(name));
503
504   slprintf(query, sizeof(query)-1, "%s%s", name, domain);
505   return(gethostbyname(query));
506 #else /* REDUCE_ROOT_DNS_LOOKUPS */
507   return(gethostbyname(name));
508 #endif /* REDUCE_ROOT_DNS_LOOKUPS */
509 }