From b0b317edbf444cfb4cc0006bbffb4b10a0b08f99 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 1 Sep 2004 01:33:55 +0000 Subject: [PATCH] r2155: Reformat, plus steal from Samba4 :-). tridge: the lp_use_mmap() in map_file() is inappropriate for 2 reasons, so I have removed it. - lp_use_mmap() is really meant to cope with systems that have broken mmap coherence, but map_file() doesn't need coherence, as its maps read only - map_file() is used to map the charset files before loadparm has loaded, so lp_use_mmap() is always returning false for the major use of map_file() Jeremy. (This used to be commit 3716dbc0cb9a8ca4027217b24dbf62a62f44e9f6) --- source3/lib/util_file.c | 492 +++++++++++++++++++++------------------- 1 file changed, 259 insertions(+), 233 deletions(-) diff --git a/source3/lib/util_file.c b/source3/lib/util_file.c index bd505ac921c..303d961df57 100644 --- a/source3/lib/util_file.c +++ b/source3/lib/util_file.c @@ -24,7 +24,6 @@ #define MAP_FAILED ((void *)-1) #endif - static int gotalarm; /*************************************************************** @@ -33,7 +32,7 @@ static int gotalarm; static void gotalarm_sig(void) { - gotalarm = 1; + gotalarm = 1; } /*************************************************************** @@ -43,34 +42,33 @@ static void gotalarm_sig(void) BOOL do_file_lock(int fd, int waitsecs, int type) { - SMB_STRUCT_FLOCK lock; - int ret; - void (*oldsig_handler)(int); - - gotalarm = 0; - oldsig_handler = CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig); - - lock.l_type = type; - lock.l_whence = SEEK_SET; - lock.l_start = 0; - lock.l_len = 1; - lock.l_pid = 0; - - alarm(waitsecs); - /* Note we must *NOT* use sys_fcntl here ! JRA */ - ret = fcntl(fd, SMB_F_SETLKW, &lock); - alarm(0); - CatchSignal(SIGALRM, SIGNAL_CAST oldsig_handler); - - if (gotalarm) { - DEBUG(0, ("do_file_lock: failed to %s file.\n", - type == F_UNLCK ? "unlock" : "lock")); - return False; - } - - return (ret == 0); -} + SMB_STRUCT_FLOCK lock; + int ret; + void (*oldsig_handler)(int); + + gotalarm = 0; + oldsig_handler = CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig); + + lock.l_type = type; + lock.l_whence = SEEK_SET; + lock.l_start = 0; + lock.l_len = 1; + lock.l_pid = 0; + + alarm(waitsecs); + /* Note we must *NOT* use sys_fcntl here ! JRA */ + ret = fcntl(fd, SMB_F_SETLKW, &lock); + alarm(0); + CatchSignal(SIGALRM, SIGNAL_CAST oldsig_handler); + + if (gotalarm) { + DEBUG(0, ("do_file_lock: failed to %s file.\n", + type == F_UNLCK ? "unlock" : "lock")); + return False; + } + return (ret == 0); +} /*************************************************************** Lock an fd. Abandon after waitsecs seconds. @@ -78,21 +76,19 @@ BOOL do_file_lock(int fd, int waitsecs, int type) BOOL file_lock(int fd, int type, int secs, int *plock_depth) { - if (fd < 0) - return False; + if (fd < 0) + return False; - (*plock_depth)++; + (*plock_depth)++; - if ((*plock_depth) == 0) - { - if (!do_file_lock(fd, secs, type)) { - DEBUG(10,("file_lock: locking file failed, error = %s.\n", - strerror(errno))); - return False; - } - } + if ((*plock_depth) == 0) { + if (!do_file_lock(fd, secs, type)) { + DEBUG(10,("file_lock: locking file failed, error = %s.\n", strerror(errno))); + return False; + } + } - return True; + return True; } /*************************************************************** @@ -101,105 +97,107 @@ BOOL file_lock(int fd, int type, int secs, int *plock_depth) BOOL file_unlock(int fd, int *plock_depth) { - BOOL ret=True; + BOOL ret=True; - if(*plock_depth == 1) - ret = do_file_lock(fd, 5, F_UNLCK); + if(*plock_depth == 1) { + ret = do_file_lock(fd, 5, F_UNLCK); + } - (*plock_depth)--; + (*plock_depth)--; - if(!ret) - DEBUG(10,("file_unlock: unlocking file failed, error = %s.\n", - strerror(errno))); - return ret; + if(!ret) { + DEBUG(10,("file_unlock: unlocking file failed, error = %s.\n", strerror(errno))); + } + return ret; } /*************************************************************** - locks a file for enumeration / modification. + Locks a file for enumeration / modification. update to be set = True if modification is required. ****************************************************************/ void *startfilepwent(char *pfile, char *s_readbuf, int bufsize, int *file_lock_depth, BOOL update) { - FILE *fp = NULL; + FILE *fp = NULL; - if (!*pfile) - { - DEBUG(0, ("startfilepwent: No file set\n")); - return (NULL); - } - DEBUG(10, ("startfilepwent: opening file %s\n", pfile)); + if (!*pfile) { + DEBUG(0, ("startfilepwent: No file set\n")); + return (NULL); + } + DEBUG(10, ("startfilepwent: opening file %s\n", pfile)); - fp = sys_fopen(pfile, update ? "r+b" : "rb"); + fp = sys_fopen(pfile, update ? "r+b" : "rb"); - if (fp == NULL) { - DEBUG(0, ("startfilepwent: unable to open file %s\n", pfile)); - return NULL; - } + if (fp == NULL) { + DEBUG(0, ("startfilepwent: unable to open file %s\n", pfile)); + return NULL; + } - /* Set a buffer to do more efficient reads */ - setvbuf(fp, s_readbuf, _IOFBF, bufsize); + /* Set a buffer to do more efficient reads */ + setvbuf(fp, s_readbuf, _IOFBF, bufsize); - if (!file_lock(fileno(fp), (update ? F_WRLCK : F_RDLCK), 5, file_lock_depth)) - { - DEBUG(0, ("startfilepwent: unable to lock file %s\n", pfile)); - fclose(fp); - return NULL; - } + if (!file_lock(fileno(fp), (update ? F_WRLCK : F_RDLCK), 5, file_lock_depth)) { + DEBUG(0, ("startfilepwent: unable to lock file %s\n", pfile)); + fclose(fp); + return NULL; + } - /* Make sure it is only rw by the owner */ - chmod(pfile, 0600); + /* Make sure it is only rw by the owner */ + chmod(pfile, 0600); - /* We have a lock on the file. */ - return (void *)fp; + /* We have a lock on the file. */ + return (void *)fp; } /*************************************************************** End enumeration of the file. ****************************************************************/ + void endfilepwent(void *vp, int *file_lock_depth) { - FILE *fp = (FILE *)vp; + FILE *fp = (FILE *)vp; - file_unlock(fileno(fp), file_lock_depth); - fclose(fp); - DEBUG(7, ("endfilepwent: closed file.\n")); + file_unlock(fileno(fp), file_lock_depth); + fclose(fp); + DEBUG(7, ("endfilepwent: closed file.\n")); } /************************************************************************* Return the current position in the file list as an SMB_BIG_UINT. This must be treated as an opaque token. *************************************************************************/ + SMB_BIG_UINT getfilepwpos(void *vp) { - return (SMB_BIG_UINT)sys_ftell((FILE *)vp); + return (SMB_BIG_UINT)sys_ftell((FILE *)vp); } /************************************************************************* Set the current position in the file list from an SMB_BIG_UINT. This must be treated as an opaque token. *************************************************************************/ + BOOL setfilepwpos(void *vp, SMB_BIG_UINT tok) { - return !sys_fseek((FILE *)vp, (SMB_OFF_T)tok, SEEK_SET); + return !sys_fseek((FILE *)vp, (SMB_OFF_T)tok, SEEK_SET); } /************************************************************************* - gets a line out of a file. + Gets a line out of a file. line is of format "xxxx:xxxxxx:xxxxx:". lines with "#" at the front are ignored. *************************************************************************/ + int getfileline(void *vp, char *linebuf, int linebuf_size) { /* Static buffers we will return. */ FILE *fp = (FILE *)vp; unsigned char c; unsigned char *p; - size_t linebuf_len; + size_t linebuf_len; - if (fp == NULL) - { + if (fp == NULL) { DEBUG(0,("getfileline: Bad file pointer.\n")); return -1; } @@ -207,13 +205,11 @@ int getfileline(void *vp, char *linebuf, int linebuf_size) /* * Scan the file, a line at a time. */ - while (!feof(fp)) - { + while (!feof(fp)) { linebuf[0] = '\0'; fgets(linebuf, linebuf_size, fp); - if (ferror(fp)) - { + if (ferror(fp)) { return -1; } @@ -223,47 +219,38 @@ int getfileline(void *vp, char *linebuf, int linebuf_size) */ linebuf_len = strlen(linebuf); - if (linebuf_len == 0) - { + if (linebuf_len == 0) { linebuf[0] = '\0'; return 0; } - if (linebuf[linebuf_len - 1] != '\n') - { + if (linebuf[linebuf_len - 1] != '\n') { c = '\0'; - while (!ferror(fp) && !feof(fp)) - { + while (!ferror(fp) && !feof(fp)) { c = fgetc(fp); - if (c == '\n') - { + if (c == '\n') { break; } } - } - else - { + } else { linebuf[linebuf_len - 1] = '\0'; } #ifdef DEBUG_PASSWORD DEBUG(100, ("getfileline: got line |%s|\n", linebuf)); #endif - if ((linebuf[0] == 0) && feof(fp)) - { + if ((linebuf[0] == 0) && feof(fp)) { DEBUG(4, ("getfileline: end of file reached\n")); return 0; } - if (linebuf[0] == '#' || linebuf[0] == '\0') - { + if (linebuf[0] == '#' || linebuf[0] == '\0') { DEBUG(6, ("getfileline: skipping comment or blank line\n")); continue; } p = (unsigned char *) strchr_m(linebuf, ':'); - if (p == NULL) - { + if (p == NULL) { DEBUG(0, ("getfileline: malformed line entry (no :)\n")); continue; } @@ -272,85 +259,89 @@ int getfileline(void *vp, char *linebuf, int linebuf_size) return -1; } - /**************************************************************************** -read a line from a file with possible \ continuation chars. -Blanks at the start or end of a line are stripped. -The string will be allocated if s2 is NULL + Read a line from a file with possible \ continuation chars. + Blanks at the start or end of a line are stripped. + The string will be allocated if s2 is NULL. ****************************************************************************/ + char *fgets_slash(char *s2,int maxlen,XFILE *f) { - char *s=s2; - int len = 0; - int c; - BOOL start_of_line = True; - - if (x_feof(f)) - return(NULL); - - if (maxlen <2) return(NULL); - - if (!s2) - { - maxlen = MIN(maxlen,8); - s = (char *)malloc(maxlen); - } - - if (!s) return(NULL); - - *s = 0; - - while (len < maxlen-1) - { - c = x_getc(f); - switch (c) - { - case '\r': - break; - case '\n': - while (len > 0 && s[len-1] == ' ') - { - s[--len] = 0; - } - if (len > 0 && s[len-1] == '\\') - { - s[--len] = 0; - start_of_line = True; - break; - } - return(s); - case EOF: - if (len <= 0 && !s2) - SAFE_FREE(s); - return(len>0?s:NULL); - case ' ': - if (start_of_line) - break; - default: - start_of_line = False; - s[len++] = c; - s[len] = 0; - } - if (!s2 && len > maxlen-3) - { - char *t; + char *s=s2; + int len = 0; + int c; + BOOL start_of_line = True; + + if (x_feof(f)) { + return(NULL); + } + + if (maxlen <2) { + return(NULL); + } + + if (!s2) { + maxlen = MIN(maxlen,8); + s = (char *)malloc(maxlen); + } + + if (!s) { + return(NULL); + } + + *s = 0; + + while (len < maxlen-1) { + c = x_getc(f); + switch (c) { + case '\r': + break; + case '\n': + while (len > 0 && s[len-1] == ' ') { + s[--len] = 0; + } + if (len > 0 && s[len-1] == '\\') { + s[--len] = 0; + start_of_line = True; + break; + } + return(s); + case EOF: + if (len <= 0 && !s2) { + SAFE_FREE(s); + } + return(len>0?s:NULL); + case ' ': + if (start_of_line) { + break; + } + default: + start_of_line = False; + s[len++] = c; + s[len] = 0; + } + + if (!s2 && len > maxlen-3) { + char *t; - maxlen *= 2; - t = (char *)Realloc(s,maxlen); - if (!t) { - DEBUG(0,("fgets_slash: failed to expand buffer!\n")); - SAFE_FREE(s); - return(NULL); - } else s = t; - } - } - return(s); + maxlen *= 2; + t = (char *)Realloc(s,maxlen); + if (!t) { + DEBUG(0,("fgets_slash: failed to expand buffer!\n")); + SAFE_FREE(s); + return(NULL); + } else { + s = t; + } + } + } + return(s); } - /**************************************************************************** -load from a pipe into memory + Load from a pipe into memory. ****************************************************************************/ + char *file_pload(char *syscmd, size_t *size) { int fd, n; @@ -359,7 +350,9 @@ char *file_pload(char *syscmd, size_t *size) size_t total; fd = sys_popen(syscmd); - if (fd == -1) return NULL; + if (fd == -1) { + return NULL; + } p = NULL; total = 0; @@ -371,7 +364,9 @@ char *file_pload(char *syscmd, size_t *size) close(fd); SAFE_FREE(p); return NULL; - } else p = tp; + } else { + p = tp; + } memcpy(p+total, buf, n); total += n; } @@ -382,13 +377,15 @@ char *file_pload(char *syscmd, size_t *size) * truncated. */ sys_pclose(fd); - if (size) *size = total; + if (size) { + *size = total; + } return p; } /**************************************************************************** -load a file into memory from a fd. + Load a file into memory from a fd. ****************************************************************************/ char *fd_load(int fd, size_t *size) @@ -396,10 +393,14 @@ char *fd_load(int fd, size_t *size) SMB_STRUCT_STAT sbuf; char *p; - if (sys_fstat(fd, &sbuf) != 0) return NULL; + if (sys_fstat(fd, &sbuf) != 0) { + return NULL; + } p = (char *)malloc(sbuf.st_size+1); - if (!p) return NULL; + if (!p) { + return NULL; + } if (read(fd, p, sbuf.st_size) != sbuf.st_size) { SAFE_FREE(p); @@ -407,79 +408,85 @@ char *fd_load(int fd, size_t *size) } p[sbuf.st_size] = 0; - if (size) *size = sbuf.st_size; + if (size) { + *size = sbuf.st_size; + } return p; } /**************************************************************************** -load a file into memory + Load a file into memory. ****************************************************************************/ + char *file_load(const char *fname, size_t *size) { int fd; char *p; - if (!fname || !*fname) return NULL; + if (!fname || !*fname) { + return NULL; + } fd = open(fname,O_RDONLY); - if (fd == -1) return NULL; + if (fd == -1) { + return NULL; + } p = fd_load(fd, size); - close(fd); - return p; } - /******************************************************************* -mmap (if possible) or read a file + mmap (if possible) or read a file. ********************************************************************/ + void *map_file(char *fname, size_t size) { size_t s2 = 0; void *p = NULL; #ifdef HAVE_MMAP - if (lp_use_mmap()) { - int fd; - fd = open(fname, O_RDONLY, 0); - if (fd == -1) { - DEBUG(2,("Failed to load %s - %s\n", fname, strerror(errno))); - return NULL; - } - p = mmap(NULL, size, PROT_READ, MAP_SHARED|MAP_FILE, fd, 0); - close(fd); - if (p == MAP_FAILED) { - DEBUG(1,("Failed to mmap %s - %s\n", fname, strerror(errno))); - return NULL; - } + int fd; + fd = open(fname, O_RDONLY, 0); + if (fd == -1) { + DEBUG(2,("map_file: Failed to load %s - %s\n", fname, strerror(errno))); + return NULL; + } + p = mmap(NULL, size, PROT_READ, MAP_SHARED|MAP_FILE, fd, 0); + close(fd); + if (p == MAP_FAILED) { + DEBUG(1,("map_file: Failed to mmap %s - %s\n", fname, strerror(errno))); + return NULL; } #endif if (!p) { p = file_load(fname, &s2); - if (!p) return NULL; + if (!p) { + return NULL; + } if (s2 != size) { - DEBUG(1,("incorrect size for %s - got %lu expected %lu\n", + DEBUG(1,("map_file: incorrect size for %s - got %lu expected %lu\n", fname, (unsigned long)s2, (unsigned long)size)); - if (p) free(p); + SAFE_FREE(p); return NULL; } } - return p; } - /**************************************************************************** -parse a buffer into lines + Parse a buffer into lines. ****************************************************************************/ + static char **file_lines_parse(char *p, size_t size, int *numlines) { int i; char *s, **ret; - if (!p) return NULL; + if (!p) { + return NULL; + } for (s = p, i=0; s < p+size; s++) { if (s[0] == '\n') i++; @@ -491,7 +498,9 @@ static char **file_lines_parse(char *p, size_t size, int *numlines) return NULL; } memset(ret, 0, sizeof(ret[0])*(i+2)); - if (numlines) *numlines = i; + if (numlines) { + *numlines = i; + } ret[0] = p; for (s = p, i=0; s < p+size; s++) { @@ -500,75 +509,87 @@ static char **file_lines_parse(char *p, size_t size, int *numlines) i++; ret[i] = s+1; } - if (s[0] == '\r') s[0] = 0; + if (s[0] == '\r') { + s[0] = 0; + } } return ret; } - /**************************************************************************** -load a file into memory and return an array of pointers to lines in the file -must be freed with file_lines_free(). + Load a file into memory and return an array of pointers to lines in the file + must be freed with file_lines_free(). ****************************************************************************/ + char **file_lines_load(const char *fname, int *numlines) { char *p; size_t size; p = file_load(fname, &size); - if (!p) return NULL; + if (!p) { + return NULL; + } return file_lines_parse(p, size, numlines); } /**************************************************************************** -load a fd into memory and return an array of pointers to lines in the file -must be freed with file_lines_free(). If convert is true calls unix_to_dos on -the list. + Load a fd into memory and return an array of pointers to lines in the file + must be freed with file_lines_free(). If convert is true calls unix_to_dos on + the list. ****************************************************************************/ + char **fd_lines_load(int fd, int *numlines) { char *p; size_t size; p = fd_load(fd, &size); - if (!p) return NULL; + if (!p) { + return NULL; + } return file_lines_parse(p, size, numlines); } - /**************************************************************************** -load a pipe into memory and return an array of pointers to lines in the data -must be freed with file_lines_free(). + Load a pipe into memory and return an array of pointers to lines in the data + must be freed with file_lines_free(). ****************************************************************************/ + char **file_lines_pload(char *syscmd, int *numlines) { char *p; size_t size; p = file_pload(syscmd, &size); - if (!p) return NULL; + if (!p) { + return NULL; + } return file_lines_parse(p, size, numlines); } /**************************************************************************** -free lines loaded with file_lines_load + Free lines loaded with file_lines_load. ****************************************************************************/ + void file_lines_free(char **lines) { - if (!lines) return; + if (!lines) { + return; + } SAFE_FREE(lines[0]); SAFE_FREE(lines); } - /**************************************************************************** -take a lislist of lines and modify them to produce a list where \ continues -a line + Take a list of lines and modify them to produce a list where \ continues + a line. ****************************************************************************/ + void file_lines_slashcont(char **lines) { int i, j; @@ -579,8 +600,12 @@ void file_lines_slashcont(char **lines) lines[i][len-1] = ' '; if (lines[i+1]) { char *p = &lines[i][len]; - while (p < lines[i+1]) *p++ = ' '; - for (j = i+1; lines[j]; j++) lines[j] = lines[j+1]; + while (p < lines[i+1]) { + *p++ = ' '; + } + for (j = i+1; lines[j]; j++) { + lines[j] = lines[j+1]; + } } } else { i++; @@ -588,9 +613,10 @@ void file_lines_slashcont(char **lines) } } -/* - save a lump of data into a file. Mostly used for debugging -*/ +/**************************************************************************** + Save a lump of data into a file. Mostly used for debugging. +****************************************************************************/ + BOOL file_save(const char *fname, void *packet, size_t length) { int fd; -- 2.34.1