diff --git a/vfs/ChangeLog b/vfs/ChangeLog index 09608cf74..d94dc4a13 100644 --- a/vfs/ChangeLog +++ b/vfs/ChangeLog @@ -1,5 +1,12 @@ 2002-08-15 Pavel Roskin + * extfs.c (s_readdir): Simplify. + * direntry.c (vfs_s_readdir): Use vfs_dirent. + * mcfs.c (mcfs_readdir): Likewise. + * smbfs.c (smbfs_readdir): Likewise. + * undelfs.c (undelfs_readdir): Use vfs_dirent and + compute_namelen(). + * vfs.h: Introduce union vfs_dirent to ensure that we have enough space for the filename. * extfs.c (s_readdir): Use vfs_dirent. Avoid strcpy(). diff --git a/vfs/direntry.c b/vfs/direntry.c index 72a6bf210..6cbad3056 100644 --- a/vfs/direntry.c +++ b/vfs/direntry.c @@ -613,29 +613,25 @@ vfs_s_opendir (vfs *me, char *dirname) } void * -vfs_s_readdir (void *data) +vfs_s_readdir(void *data) { - static struct { - struct dirent dir; -#ifdef NEED_EXTRA_DIRENT_BUFFER - char extra_buffer [MC_MAXPATHLEN]; -#endif - } dir; - + static union vfs_dirent dir; struct dirhandle *info = (struct dirhandle *) data; if (!(info->cur)) - return NULL; + return NULL; - if (info->cur->name) - strcpy (&(dir.dir.d_name [0]), info->cur->name); - else - vfs_die ("Null in structure-can not happen"); + if (info->cur->name) { + strncpy(dir.dent.d_name, info->cur->name, MC_MAXPATHLEN); + dir.dent.d_name[MC_MAXPATHLEN] = 0; + } else { + vfs_die("Null in structure-can not happen"); + } - compute_namelen(&dir.dir); + compute_namelen(&dir.dent); info->cur = info->cur->next; - - return (void *)&dir; + + return (void *) &dir; } int diff --git a/vfs/extfs.c b/vfs/extfs.c index 57b0a9bb3..c403334ac 100644 --- a/vfs/extfs.c +++ b/vfs/extfs.c @@ -880,25 +880,21 @@ static void * s_opendir (vfs *me, char *dirname) return info; } -static void * s_readdir (void *data) +static void * s_readdir(void *data) { static union vfs_dirent dir; - int namelen; - struct entry **info = (struct entry **) data; if (!*info) - return NULL; + return NULL; - namelen = min (strlen ((*info)->name), MC_MAXPATHLEN); + strncpy(dir.dent.d_name, (*info)->name, MC_MAXPATHLEN); + dir.dent.d_name[MC_MAXPATHLEN] = 0; - strncpy (dir.dent.d_name, (*info)->name, namelen); - dir.dent.d_name[namelen] = 0; - - compute_namelen (&dir.dent); + compute_namelen(&dir.dent); *info = (*info)->next_in_dir; - - return (void *)&dir; + + return (void *) &dir; } static int s_telldir (void *data) diff --git a/vfs/mcfs.c b/vfs/mcfs.c index 59e15c8ae..6fe373c00 100644 --- a/vfs/mcfs.c +++ b/vfs/mcfs.c @@ -710,46 +710,38 @@ static void mcfs_free_dir (dir_entry *de) g_free (de); } -/* Explanation: - * On some operating systems (Slowaris 2 for example) - * the d_name member is just a char long (Nice trick that break everything, - * so we need to set up some space for the filename. - */ -static struct { - struct dirent dent; -#ifdef NEED_EXTRA_DIRENT_BUFFER - char extra_buffer [MC_MAXPATHLEN]; -#endif -} mcfs_readdir_data; +static union vfs_dirent mcfs_readdir_data; /* The readdir routine loads the complete directory */ /* It's too slow to ask the server each time */ /* It now also sends the complete lstat information for each file */ static struct stat *cached_lstat_info; -static void *mcfs_readdir (void *info) + +static void *mcfs_readdir(void *info) { - opendir_info *mcfs_info; + opendir_info *mcfs_info; char *dirent_dest; mcfs_info = (opendir_info *) info; if (!mcfs_info->entries) - if (!mcfs_loaddir (mcfs_info)) + if (!mcfs_loaddir(mcfs_info)) return NULL; - if (mcfs_info->current == 0){ + if (mcfs_info->current == 0) { cached_lstat_info = 0; - mcfs_free_dir (mcfs_info->entries); + mcfs_free_dir(mcfs_info->entries); mcfs_info->entries = 0; return NULL; } - dirent_dest = &(mcfs_readdir_data.dent.d_name [0]); - strcpy (dirent_dest, mcfs_info->current->text); + dirent_dest = mcfs_readdir_data.dent.d_name; + strncpy(dirent_dest, mcfs_info->current->text, MC_MAXPATHLEN); + dirent_dest[MC_MAXPATHLEN] = 0; cached_lstat_info = &mcfs_info->current->my_stat; mcfs_info->current = mcfs_info->current->next; - compute_namelen (&mcfs_readdir_data.dent); - + compute_namelen(&mcfs_readdir_data.dent); + return &mcfs_readdir_data; } diff --git a/vfs/smbfs.c b/vfs/smbfs.c index a8f31d9bd..12d62622d 100644 --- a/vfs/smbfs.c +++ b/vfs/smbfs.c @@ -720,48 +720,38 @@ smbfs_free_dir (dir_entry *de) } #endif -/* Explanation: - * On some operating systems (Slowaris 2 for example) - * the d_name member is just a char long (Nice trick that break everything, - * so we need to set up some space for the filename. - */ -static struct { - struct dirent dent; -#ifdef NEED_EXTRA_DIRENT_BUFFER - char extra_buffer [MC_MAXPATHLEN]; -#endif -} smbfs_readdir_data; - /* The readdir routine loads the complete directory */ /* It's too slow to ask the server each time */ /* It now also sends the complete lstat information for each file */ static void * -smbfs_readdir (void *info) +smbfs_readdir(void *info) { - static char * const dirent_dest = &(smbfs_readdir_data.dent.d_name [0]); - opendir_info *smbfs_info = (opendir_info *) info; + static union vfs_dirent smbfs_readdir_data; + static char *const dirent_dest = smbfs_readdir_data.dent.d_name; + opendir_info *smbfs_info = (opendir_info *) info; DEBUG(4, ("smbfs_readdir(%s)\n", smbfs_info->dirname)); - + if (!smbfs_info->entries) - if (!smbfs_loaddir (smbfs_info)) - return NULL; + if (!smbfs_loaddir(smbfs_info)) + return NULL; if (smbfs_info->current == 0) { /* reached end of dir entries */ - DEBUG(3, ("smbfs_readdir: smbfs_info->current = 0\n")); + DEBUG(3, ("smbfs_readdir: smbfs_info->current = 0\n")); #ifdef SMBFS_FREE_DIR - smbfs_free_dir (smbfs_info->entries); - smbfs_info->entries = 0; + smbfs_free_dir(smbfs_info->entries); + smbfs_info->entries = 0; #endif - return NULL; + return NULL; } - pstrcpy (dirent_dest, smbfs_info->current->text); + strncpy(dirent_dest, smbfs_info->current->text, MC_MAXPATHLEN); + dirent_dest[MC_MAXPATHLEN] = 0; smbfs_info->current = smbfs_info->current->next; compute_namelen(&smbfs_readdir_data.dent); - return &smbfs_readdir_data; + return &smbfs_readdir_data; } static int diff --git a/vfs/undelfs.c b/vfs/undelfs.c index 4b000eb28..5b424ba19 100644 --- a/vfs/undelfs.c +++ b/vfs/undelfs.c @@ -319,41 +319,31 @@ quit_opendir: return 0; } -/* Explanation: - * On some operating systems (Slowaris 2 for example) - * the d_name member is just a char long (Nice trick that break everything, - * so we need to set up some space for the filename. - */ -static struct { - struct dirent dent; -#ifdef NEED_EXTRA_DIRENT_BUFFER - char extra_buffer [MC_MAXPATHLEN]; -#endif -} undelfs_readdir_data; static void * -undelfs_readdir (void *vfs_info) +undelfs_readdir(void *vfs_info) { + static union vfs_dirent undelfs_readdir_data; char *dirent_dest; - - if (vfs_info != fs){ - message_1s (1, undelfserr, _(" vfs_info is not fs! ")); + + if (vfs_info != fs) { + message_1s(1, undelfserr, _(" vfs_info is not fs! ")); return NULL; } if (readdir_ptr == num_delarray) return NULL; - dirent_dest = (char *) &(undelfs_readdir_data.dent.d_name [0]); + dirent_dest = undelfs_readdir_data.dent.d_name; if (readdir_ptr < 0) - g_snprintf(dirent_dest, MC_MAXPATHLEN, "%s", readdir_ptr == -2 ? "." : ".."); + g_snprintf(dirent_dest, MC_MAXPATHLEN, "%s", + readdir_ptr == -2 ? "." : ".."); else g_snprintf(dirent_dest, MC_MAXPATHLEN, "%ld:%d", - (long)delarray [readdir_ptr].ino, - delarray [readdir_ptr].num_blocks); + (long) delarray[readdir_ptr].ino, + delarray[readdir_ptr].num_blocks); readdir_ptr++; - -#if 0 - undelfs_readdir_data.dent.d_namlen = strlen (undelfs_readdir_data.dent.d_name); -#endif + + compute_namelen(&undelfs_readdir_data.dent); + return &undelfs_readdir_data; }