Code cleaning

1 files changed, 233 insertions, 172 deletions

diff --git a/smbnetfs.c b/smbnetfs.c
index e252a5698..c673dd45c 100644
--- a/smbnetfs.c
+++ b/smbnetfs.c
@@ -1,6 +1,6 @@
 /*
-  Copyright (C) 1997, 2002, 2004, 2007 Free Software Foundation, Inc.
-  Copyright (C) 2004, 2007 Giuseppe Scrivano.
+  Copyright (C) 1997, 2002, 2004, 2007, 2009 Free Software Foundation, Inc.
+  Copyright (C) 2004, 2007, 2009 Giuseppe Scrivano.
   Written by Giuseppe Scrivano <gscrivano@gnu.org>
 
   This program is free software; you can redistribute it and/or
@@ -32,11 +32,13 @@
 #define DIRENT_NAME_OFFS offsetof (struct dirent, d_name)
 /* Length is structure before the name + the name + '\0', all
    padded to a four-byte alignment.  */
-#define DIRENT_LEN(name_len)    ((DIRENT_NAME_OFFS + (name_len) + 1 + (DIRENT_ALIGN - 1)) & ~(DIRENT_ALIGN - 1))
+#define DIRENT_LEN(name_len)    ((DIRENT_NAME_OFFS + (name_len) + 1 \
+                               + (DIRENT_ALIGN - 1)) & ~(DIRENT_ALIGN - 1))
 
 struct smb_credentials credentials;
 static volatile struct mapped_time_value *maptime;
 static struct mutex smb_mutex;
+
 char *netfs_server_name = "smbfs";
 char *netfs_server_version = "0.1";
 int netfs_maxsymlinks = 0;
@@ -64,39 +66,41 @@ clear_nodes ()
     {
       pt2 = pt;
       if (pt2)
-	{
-	  pt = pt->next;
-	  free (pt2->node);
-	  free (pt2->filename);
-	  free (pt2);
-	}
+        {
+          pt = pt->next;
+          free (pt2->node);
+          free (pt2->filename);
+          free (pt2);
+        }
       else
-	{
-	  break;
-	}
+        break;
     }
   nodes = 0;
 }
+
 void
-append_node_to_list(struct netnode *n)
+append_node_to_list (struct netnode *n)
 {
-  n->next=nodes;
-  nodes=n;
+  n->next = nodes;
+  nodes = n;
 }
+
 /* Create a new node and initialize it with default values.  */
 int
-create_node(struct node **node)
+create_node (struct node **node)
 {
   struct netnode *n = malloc (sizeof (struct netnode));
+
   if(!n)
   	return ENOMEM;
+
   *node = n->node = netfs_make_node (n);
   if (!(*node))
     {
       free (n);
       return ENOMEM;
     }  
-  append_node_to_list(n);
+  append_node_to_list (n);
   return 0;
 }
 
@@ -104,17 +108,16 @@ struct netnode *
 search_node (char *filename, struct node *dir)
 {
   struct netnode *pt = nodes;
+
   while (pt)
     {
-      if ((pt->parent)  && (dir == pt->parent->node))
-	{
-	  if (!strcmp (pt->filename, filename))
-	    {
-	      return pt;
-	    }
-	}
+      if ((pt->parent)  && (dir == pt->parent->node)
+          && !strcmp (pt->filename, filename))
+            return pt;
+
       pt = pt->next;
     }
+
   return 0;
 }
 
@@ -127,18 +130,20 @@ remove_node (struct node *np)
   for ( pt=nodes, prevpt=0 ; pt ; pt=pt->next )
     {
       if (pt->node == np)
-	{
-	  free (pt->node);
-	  free (pt->filename);
-	  free (pt);
-	  if (prevpt)
-	    prevpt->next = pt->next;
-	  else
-	    nodes = pt->next;
-	  break;
-	}
-	else
-          prevpt = pt;
+        {
+          free (pt->node);
+          free (pt->filename);
+          free (pt);
+
+          if (prevpt)
+            prevpt->next = pt->next;
+          else
+            nodes = pt->next;
+
+          break;
+        }
+      else
+        prevpt = pt;
     }
 }
 
@@ -146,16 +151,16 @@ void
 create_root_node ()
 {
   struct node *node;
-  int err=create_node(&node);
-  if(err)
+  int err = create_node (&node);
+  if (err)
     return;  
   netfs_root_node = node;
   node->nn->parent = 0;
-  node->nn->filename = malloc(strlen(credentials.share)+1);
-  if(node->nn->filename)
-    strcpy(node->nn->filename,credentials.share);
+  node->nn->filename = malloc (strlen (credentials.share) + 1);
+  if (node->nn->filename)
+    strcpy (node->nn->filename, credentials.share);
   
-  netfs_validate_stat (node,0);
+  netfs_validate_stat (node, 0);
   
   }
 
@@ -166,37 +171,41 @@ add_node (char *filename, struct node *top ,struct netnode** nn)
   int err;
   struct netnode *n;
   struct node *newnode;
-  io_statbuf_t  st;  
+  io_statbuf_t  st;
+
   n = search_node (filename, top);
   if (n)
     {
-      *nn=n;
+      *nn = n;
       return 0;
     }
     
-  err=create_node (&newnode);
-  if(err)
+  err = create_node (&newnode);
+  if (err)
     return err;
   n = newnode->nn;
   n->node = newnode;
-  if(top)
+
+  if (top)
     n->parent = top->nn;
   else
     n->parent = 0;
+
   n->filename = malloc ( strlen(top->nn->filename) + strlen (filename) + 1);
-  if(!n->filename)
+  if (!n->filename)
     return 0;
-  sprintf (n->filename, "%s/%s", top->nn->filename , filename);
+
+  sprintf (n->filename, "%s/%s", top->nn->filename, filename);
 
   mutex_lock (&smb_mutex);  
-  err = smbc_stat(n->filename, &st);
+  err = smbc_stat (n->filename, &st);
   mutex_unlock (&smb_mutex);  
     
-  if(err)
+  if (err)
     return errno;
   
   /* Consider only directories and regular files.  */
-  if(((st.st_mode &  S_IFDIR) == 0)  && ((st.st_mode &  S_IFREG) == 0))
+  if (((st.st_mode &  S_IFDIR) == 0)  && ((st.st_mode &  S_IFREG) == 0))
     err=-1;
   if(err)
     { 
@@ -204,7 +213,7 @@ add_node (char *filename, struct node *top ,struct netnode** nn)
       return errno;
     }
     
-  *nn=n;
+  *nn = n;
   return 0;
 }
 
@@ -212,10 +221,10 @@ error_t
 netfs_validate_stat (struct node * np, struct iouser *cred)
 {
   mutex_lock (&smb_mutex);    
-  int err = smbc_stat(np->nn->filename, &np->nn_stat);
+  int err = smbc_stat (np->nn->filename, &np->nn_stat);
   mutex_unlock (&smb_mutex);
-  if(err)
-      return errno;
+  if (err)
+    return errno;
     
   return 0;
 }
@@ -238,9 +247,10 @@ netfs_attempt_chmod (struct iouser * cred, struct node * np, mode_t mode)
 {
   int err;
   mutex_lock (&smb_mutex);    
-  err=smbc_chmod(np->nn->filename,mode);
+  err=smbc_chmod (np->nn->filename,mode);
   mutex_unlock (&smb_mutex);  
-  if(err)
+
+  if (err)
     return errno;
   else 
     return 0;
@@ -282,14 +292,16 @@ netfs_attempt_utimes (struct iouser * cred, struct node * np,
 {
   int err;
   struct timeval tv;
-  tv.tv_usec=0;/* Not used by samba.  */
-  if(mtime)
-    tv.tv_sec=mtime->tv_sec;
+  tv.tv_usec = 0;/* Not used by samba.  */
+  if (mtime)
+    tv.tv_sec = mtime->tv_sec;
   else
-    maptime_read(maptime, &tv);
+    maptime_read (maptime, &tv);
+
   mutex_lock (&smb_mutex);    
-  err=smbc_utimes(np->nn->filename,&tv);
+  err = smbc_utimes (np->nn->filename, &tv);
   mutex_unlock (&smb_mutex);
+
   if(err)
     return errno;
   else 
@@ -299,37 +311,44 @@ netfs_attempt_utimes (struct iouser * cred, struct node * np,
 error_t
 netfs_attempt_set_size (struct iouser * cred, struct node * np, loff_t size)
 {
+  int ret = 0;
+  int fd;
+  int current_filesize;
   
   mutex_lock (&smb_mutex);  
-  int fd = smbc_open (np->nn->filename, O_WRONLY | O_CREAT, O_RDWR);
+  fd = smbc_open (np->nn->filename, O_WRONLY | O_CREAT, O_RDWR);
   mutex_unlock (&smb_mutex);  
-  int ret=0;
+
   if (fd < 0)
-    {
-      return errno;
-    }
+    return errno;
+
   mutex_lock (&smb_mutex);  
-  int current_filesize = smbc_lseek (fd, 0, SEEK_END);
+
+  current_filesize = smbc_lseek (fd, 0, SEEK_END);
+
   mutex_unlock (&smb_mutex);    
-  if(current_filesize<0)
+
+  if (current_filesize < 0)
     {
       mutex_lock (&smb_mutex);
       smbc_close (fd);
       mutex_unlock (&smb_mutex);
       return errno;    
     }
-  if(current_filesize<size)
+
+  if (current_filesize < size)
     {
       /* FIXME. trunc here.  */  
       mutex_lock (&smb_mutex);
       smbc_close (fd);
       fd = smbc_open (np->nn->filename, O_WRONLY | O_TRUNC, O_RDWR);
       mutex_unlock (&smb_mutex);
-      current_filesize=0;
+      current_filesize = 0;
     }
   mutex_lock (&smb_mutex);
   ret=smbc_lseek (fd, size, SEEK_SET);
   mutex_unlock (&smb_mutex);
+
   if (ret < 0)
     {
       mutex_lock (&smb_mutex);
@@ -337,6 +356,7 @@ netfs_attempt_set_size (struct iouser * cred, struct node * np, loff_t size)
       mutex_unlock (&smb_mutex);
       return errno;
     }
+
   mutex_lock (&smb_mutex);
   smbc_close (fd);
   mutex_unlock (&smb_mutex);
@@ -367,7 +387,9 @@ error_t
 netfs_attempt_lookup (struct iouser * user, struct node * dir, char *name,
 		      struct node ** np)
 {
+  struct netnode *n;
   error_t err = 0;
+
   if (*name == '\0' || strcmp (name, ".") == 0)	/*Current directory */
     {
       netfs_nref (dir);/*Add a reference to current directory */
@@ -378,35 +400,39 @@ netfs_attempt_lookup (struct iouser * user, struct node * dir, char *name,
   else if (strcmp (name, "..") == 0)	/*Parent directory */
     {
       if (dir->nn->parent)
-	{
-	  *np = dir->nn->parent->node;
-	  if (*np)
-	    {
-	      netfs_nref (*np);
-	      err=0;
-	    }
-	  else
-	    err = ENOENT;
-	}
+        {
+          *np = dir->nn->parent->node;
+          if (*np)
+            {
+              netfs_nref (*np);
+              err = 0;
+            }
+          else
+            err = ENOENT;
+        }
       else
-	{
-	  err = ENOENT;
-	  *np = 0;
-	}
+        {
+          err = ENOENT;
+          *np = 0;
+        }
+
       mutex_unlock (&dir->lock);
       return err;    
     }
-  mutex_unlock (&dir->lock);
 
-  struct netnode *n;
+  mutex_unlock (&dir->lock);
   
   err = add_node (name, dir,&n);
+
   if(err)
     return err;
+
   *np = n->node;
   netfs_nref (*np);
+
   if (*np)
     err = 0;
+
   return err;
 }
 
@@ -416,9 +442,10 @@ netfs_attempt_unlink (struct iouser * user, struct node * dir, char *name)
   char *filename;
 
   if (dir->nn->filename)
-    filename = malloc (strlen (dir->nn->filename) +      strlen (name) + 2);
+    filename = malloc (strlen (dir->nn->filename) + strlen (name) + 2);
   else
     filename = malloc (strlen (credentials.share) + strlen (name) + 1);
+
   if (!filename)
     return ENOMEM;
 
@@ -432,7 +459,8 @@ netfs_attempt_unlink (struct iouser * user, struct node * dir, char *name)
   mutex_unlock (&smb_mutex);  
   
   free (filename);
-  if(err)
+
+  if (err)
     return errno;
   else
     return 0;
@@ -447,14 +475,15 @@ netfs_attempt_rename (struct iouser * user, struct node * fromdir,
   char *filename2;		/* Destination file name.  */
 
   if (fromdir->nn->filename)
-    filename =malloc ( strlen (fromdir->nn->filename) +strlen (fromname) + 2);
+    filename = malloc (strlen (fromdir->nn->filename) + strlen (fromname) + 2);
   else
     filename = malloc (strlen (credentials.share) + strlen (fromname) + 1);
+
   if (!filename)
     return ENOMEM;
 
   if (todir->nn->filename)
-    filename2 =malloc ( strlen (todir->nn->filename) +strlen (toname) + 2);
+    filename2 =malloc (strlen (todir->nn->filename) + strlen (toname) + 2);
   else
     filename2 = malloc (strlen (credentials.share) + strlen (toname) + 1);
 
@@ -480,7 +509,7 @@ netfs_attempt_rename (struct iouser * user, struct node * fromdir,
   
   free (filename);
   free (filename2);
-  return err?errno:0;
+  return err ? errno : 0;
 }
 
 error_t
@@ -506,14 +535,15 @@ netfs_attempt_mkdir (struct iouser * user, struct node * dir, char *name,
   err = smbc_mkdir (filename, mode);
   mutex_unlock (&smb_mutex);  
   
-  free(filename);
-  return err?errno:0;
+  free (filename);
+  return err ? errno : 0;
 }
 
 error_t
 netfs_attempt_rmdir (struct iouser * user, struct node * dir, char *name)
 {
   char *filename;
+  error_t err;
 
   if (dir->nn->filename)
     filename = malloc (strlen (dir->nn->filename) +strlen (name) + 2);
@@ -528,11 +558,11 @@ netfs_attempt_rmdir (struct iouser * user, struct node * dir, char *name)
     sprintf (filename, "%s/%s", credentials.share, name);
 
   mutex_lock (&smb_mutex);
-  error_t err = smbc_rmdir (filename);
+  err = smbc_rmdir (filename);
   mutex_unlock (&smb_mutex);  
-  
+
   free(filename);
-  return err?errno:0;
+  return err ? errno : 0;
 }
 
 error_t
@@ -554,9 +584,12 @@ error_t
 netfs_attempt_create_file (struct iouser * user, struct node * dir,
 			   char *name, mode_t mode, struct node ** np)
 {
-  *np = 0;
-  error_t err=0;
+  error_t err = 0;
   char *filename;
+  struct netnode *nn;
+  int fd;
+  *np = 0;
+
   if (dir->nn->filename)
     filename = malloc ( strlen (dir->nn->filename) +strlen (name) + 2);
   else
@@ -570,7 +603,7 @@ netfs_attempt_create_file (struct iouser * user, struct node * dir,
     sprintf (filename, "%s/%s", credentials.share, name);
 
   mutex_lock (&smb_mutex);
-  int fd = smbc_open (filename,O_WRONLY | O_CREAT , O_RDWR);
+  fd = smbc_open (filename,O_WRONLY | O_CREAT , O_RDWR);
   if (fd < 0)
     {
       mutex_unlock (&smb_mutex);  
@@ -579,14 +612,15 @@ netfs_attempt_create_file (struct iouser * user, struct node * dir,
     }
   smbc_close (fd);
   mutex_unlock (&smb_mutex);    
-  
-  struct netnode *nn;
-  err=add_node (name, dir,&nn);
-  if(err)
+
+  err = add_node (name, dir, &nn);
+
+  if (err)
     {
       mutex_unlock (&dir->lock);
       return err;
     }
+
   *np = nn->node;
 
   mutex_unlock (&dir->lock);
@@ -611,9 +645,7 @@ netfs_check_open_permissions (struct iouser * user, struct node * np,
   mutex_unlock (&smb_mutex);
    
   if (err)
-    {
-      return errno;
-    }
+    return errno;
 
   if (flags & O_READ)
     err = !(S_IREAD & nn_stat.st_mode);
@@ -629,17 +661,19 @@ error_t
 netfs_attempt_read (struct iouser * cred, struct node * np, loff_t offset,
 		    size_t * len, void *data)
 {
+  int fd;
+  int ret = 0;
+
   mutex_lock (&smb_mutex);
-  int fd = smbc_open (np->nn->filename, O_RDONLY, O_RDWR);
+  fd = smbc_open (np->nn->filename, O_RDONLY, O_RDWR);
   mutex_unlock (&smb_mutex);
-  
-  int ret = 0;
 
   if (fd < 0)
     {
       *len = 0;
       return errno;
     }
+
   mutex_lock (&smb_mutex);
   ret = smbc_lseek (fd, offset, SEEK_SET);
   mutex_unlock (&smb_mutex);
@@ -652,9 +686,11 @@ netfs_attempt_read (struct iouser * cred, struct node * np, loff_t offset,
       mutex_unlock (&smb_mutex);
       return errno;
     }
+
   mutex_lock (&smb_mutex);
   ret = smbc_read (fd, data, *len);
   mutex_unlock (&smb_mutex);
+
   if (ret < 0)
     {
       *len = 0;
@@ -663,7 +699,8 @@ netfs_attempt_read (struct iouser * cred, struct node * np, loff_t offset,
       mutex_unlock (&smb_mutex);
       return errno;
     }
-  *len=ret;
+
+  *len = ret;
   mutex_lock (&smb_mutex);
   smbc_close (fd);
   mutex_unlock (&smb_mutex);
@@ -674,10 +711,13 @@ error_t
 netfs_attempt_write (struct iouser * cred, struct node * np, loff_t offset,
 		     size_t * len, void *data)
 {
+  int ret = 0;
+  int fd;
+  
   mutex_lock (&smb_mutex);
-  int fd = smbc_open (np->nn->filename, O_WRONLY, O_RDWR);
+  fd = smbc_open (np->nn->filename, O_WRONLY, O_RDWR);
   mutex_unlock (&smb_mutex);
-  int ret=0;
+
   if (fd < 0)
     {
       *len = 0;
@@ -686,6 +726,7 @@ netfs_attempt_write (struct iouser * cred, struct node * np, loff_t offset,
   mutex_lock (&smb_mutex);
   ret = smbc_lseek (fd, offset, SEEK_SET) < 0;
   mutex_unlock (&smb_mutex);
+  
   if ((ret < 0) || (ret != offset))
     {
       *len = 0;
@@ -697,6 +738,7 @@ netfs_attempt_write (struct iouser * cred, struct node * np, loff_t offset,
   mutex_lock (&smb_mutex);
   ret = smbc_write (fd, data, *len);
   mutex_unlock (&smb_mutex);
+  
   if (ret < 0)
     {
       *len = 0;
@@ -705,7 +747,8 @@ netfs_attempt_write (struct iouser * cred, struct node * np, loff_t offset,
       mutex_unlock (&smb_mutex);      
       return errno;
     }
-  *len=ret;
+
+  *len = ret;
   mutex_lock (&smb_mutex);
   smbc_close (fd);
   mutex_unlock (&smb_mutex);      
@@ -717,12 +760,14 @@ error_t
 netfs_report_access (struct iouser * cred, struct node * np, int *types)
 {
   *types = 0;
-  if(fshelp_access(&np->nn_stat, S_IREAD, cred) == 0)
+
+  if (fshelp_access (&np->nn_stat, S_IREAD, cred) == 0)
     *types |= O_READ;
-  if(fshelp_access(&np->nn_stat, S_IWRITE, cred) == 0)
+  if (fshelp_access (&np->nn_stat, S_IWRITE, cred) == 0)
     *types |= O_WRITE;
-  if(fshelp_access(&np->nn_stat, S_IEXEC, cred) == 0)
+  if (fshelp_access (&np->nn_stat, S_IEXEC, cred) == 0)
     *types |= O_EXEC;
+
   return 0;
 }
 
@@ -740,48 +785,50 @@ netfs_node_norefs (struct node *np)
 
 error_t
 netfs_get_dirents (struct iouser *cred, struct node *dir, int entry,
-		   int nentries, char **data,
-		   mach_msg_type_number_t * datacnt, vm_size_t bufsize,
-		   int *amt)
+                   int nentries, char **data,
+                   mach_msg_type_number_t * datacnt, vm_size_t bufsize,
+                   int *amt)
 {
-  if (!dir)
-    return ENOTDIR;
   io_statbuf_t  st; 
   struct smbc_dirent * dirent;  
   int size = 0,  dd;
-  int nreturningentries=0;
-  int err=0;
-  int add_dir_entry_size=0;
+  int nreturningentries = 0;
+  int err = 0;
+  int add_dir_entry_size = 0;
   char *p = 0;
 
+  if (!dir)
+    return ENOTDIR;
+
   mutex_lock (&smb_mutex);
   dd = smbc_opendir (dir->nn->filename);
   mutex_unlock (&smb_mutex);
   
-  if (dd<0)
+  if (dd < 0)
     return ENOTDIR;  
   
   mutex_lock (&smb_mutex);
-  err=smbc_lseekdir(dd, entry);
+  err = smbc_lseekdir (dd, entry);
   mutex_unlock (&smb_mutex);
   
   if(err)
     {
       if(errno == EINVAL)
         {
-          *datacnt=0;
-          *amt=0;
+          *datacnt = 0;
+          *amt = 0;
           mutex_lock (&smb_mutex);
-          smbc_closedir(dd);
+          smbc_closedir (dd);
           mutex_unlock (&smb_mutex);
           return 0;
         }
       return errno;
     }
    
-  int addSize (char *filename)
+  int
+  addSize (char *filename)
     {
-      if(nentries == -1 || nreturningentries < nentries)
+      if (nentries == -1 || nreturningentries < nentries)
         {
           size_t new_size = size + DIRENT_LEN (strlen (filename));
           if (bufsize > 0 && new_size > bufsize)
@@ -793,22 +840,26 @@ netfs_get_dirents (struct iouser *cred, struct node *dir, int entry,
       else
         return 1;
     }
+
   for(;;)
     {
       mutex_lock (&smb_mutex);      
-      dirent = smbc_readdir(dd);
+      dirent = smbc_readdir (dd);
       mutex_unlock (&smb_mutex);
+
       if(!dirent)
         break;
-      if( (dirent->smbc_type == SMBC_DIR) || (dirent->smbc_type == SMBC_FILE) )/* Add only files and directories.  */ 
-        if(addSize(dirent->name))/* bufsize or nentries reached.  */
- 	  break;
+
+      /* Add only files and directories.  */
+      if ((dirent->smbc_type == SMBC_DIR) || (dirent->smbc_type == SMBC_FILE) ) 
+        if (addSize(dirent->name))/* bufsize or nentries reached.  */
+          break;
       
     }
+
   if(size > *datacnt) /* if the supplied buffer isn't large enough.  */
-    {
-      *data = mmap (0, size, PROT_READ|PROT_WRITE, MAP_ANONYMOUS, 0, 0);
-    }
+    *data = mmap (0, size, PROT_READ|PROT_WRITE, MAP_ANONYMOUS, 0, 0);
+
   if (!(*data) ||  (*data == (void *) -1))
     {
       mutex_lock (&smb_mutex);
@@ -816,27 +867,32 @@ netfs_get_dirents (struct iouser *cred, struct node *dir, int entry,
       mutex_unlock (&smb_mutex);
       return ENOMEM;    
     }
+
   mutex_lock (&smb_mutex);
-  err=smbc_lseekdir(dd, entry);
+  err=smbc_lseekdir (dd, entry);
   mutex_unlock (&smb_mutex);
-  if(err)
+
+  if (err)
     {
-      if(errno == EINVAL)
+      if (errno == EINVAL)
         {
-          *datacnt=0;
-          *amt=0;
+          *datacnt = 0;
+          *amt = 0;
           mutex_lock (&smb_mutex);
-          smbc_closedir(dd);
+          smbc_closedir (dd);
           mutex_unlock (&smb_mutex);
           return 0;
         }
+
       return errno;
     }
       
-  add_dir_entry_size=size;
+  add_dir_entry_size = size;
   p = *data;
-  int count=0;
-  int add_dir_entry (const char *name, ino_t fileno, int type)
+  int count = 0;
+  
+  int
+  add_dir_entry (const char *name, ino_t fileno, int type)
     {
       if(count < nreturningentries)
         {
@@ -867,9 +923,9 @@ netfs_get_dirents (struct iouser *cred, struct node *dir, int entry,
     for(;;)
       {
         mutex_lock (&smb_mutex);
-        dirent = smbc_readdir(dd);
-        mutex_unlock(&smb_mutex);
-        if(!dirent)
+        dirent = smbc_readdir (dd);
+        mutex_unlock (&smb_mutex);
+        if (!dirent)
           break;
         int type = 0;
         if (dirent->smbc_type == SMBC_DIR)
@@ -878,39 +934,43 @@ netfs_get_dirents (struct iouser *cred, struct node *dir, int entry,
           type = DT_REG;
         else
           continue;
+
         char *stat_file_name;
-        stat_file_name=malloc(strlen(dir->nn->filename)+strlen(dirent->name)+2);
+        stat_file_name = malloc (strlen (dir->nn->filename)
+                                 + strlen (dirent->name) + 2);
         if(!stat_file_name)
           {
             mutex_lock (&smb_mutex);
             smbc_closedir(dd);
             mutex_unlock (&smb_mutex);
             return ENOMEM;
-          }                          
-        if(!strcmp(dirent->name,"."))
+          }                      
+    
+        if (!strcmp (dirent->name, "."))
           {
-            sprintf(stat_file_name,"%s",dir->nn->filename);
+            sprintf (stat_file_name, "%s", dir->nn->filename);
             mutex_lock (&smb_mutex);
-            err=smbc_stat(stat_file_name, &st);
+            err=smbc_stat (stat_file_name, &st);
             mutex_unlock (&smb_mutex);
           }
-        else if(!strcmp(dirent->name,".."))
+        else if (!strcmp (dirent->name,".."))
           {
-            if(dir->nn->parent)
-              sprintf(stat_file_name,"%s/%s",dir->nn->filename,dirent->name);
+            if (dir->nn->parent)
+              sprintf (stat_file_name, "%s/%s", dir->nn->filename, dirent->name);
             else
-              st.st_ino=0;
+              st.st_ino = 0;
           }
         else
           {
-            sprintf(stat_file_name,"%s/%s",dir->nn->filename,dirent->name);
+            sprintf (stat_file_name,"%s/%s", dir->nn->filename, dirent->name);
             mutex_lock (&smb_mutex);
-            err=smbc_stat(stat_file_name, &st);
-            mutex_unlock(&smb_mutex);
+            err=smbc_stat (stat_file_name, &st);
+            mutex_unlock (&smb_mutex);
           }
 
-        free(stat_file_name);
-        if(err)
+        free (stat_file_name);
+
+        if (err)
           {
             mutex_lock (&smb_mutex);
             smbc_closedir(dd);
@@ -918,15 +978,15 @@ netfs_get_dirents (struct iouser *cred, struct node *dir, int entry,
             return errno;
           }
 
-        err=add_dir_entry (dirent->name, st.st_ino, type);
+        err = add_dir_entry (dirent->name, st.st_ino, type);
         if (err)
           break;
-      }        
+      } 
 
-  *datacnt=size;
-  *amt=nreturningentries;
+  *datacnt = size;
+  *amt = nreturningentries;
   mutex_lock (&smb_mutex);
-  smbc_closedir(dd);
+  smbc_closedir (dd);
   mutex_unlock (&smb_mutex);
   return 0;
 }
@@ -936,7 +996,8 @@ smbfs_init ()
 {
   int err;
   nodes = 0;
-  err = maptime_map(0,0, &maptime);
+  err = maptime_map (0, 0, &maptime);
+
   if(err)
     return;