Logo Search packages:      
Sourcecode: ladcca version File versions  Download package

file.c

/*
 *   LADCCA
 *    
 *   Copyright (C) 2002 Robert Ham <rah@bash.sh>
 *    
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <stdlib.h>
#include <sys/types.h>
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
                     
#include <ladcca/ladcca.h>

int
cca_file_exists (const char * file)
{
  int err;
  struct stat filestat;
  
  err = stat (file, &filestat);
  if (err == -1)
    return 0;

  return 1;
}

int
cca_dir_exists (const char * dir)
{
  DIR * dirstream;
  
  dirstream = opendir (dir);
  if (dirstream)
    {
      closedir (dirstream);
      return 1;
    }
  
  return 0;  
}

const char *
cca_get_fqn (const char * param_dir, const char * param_file)
{
  static char * fqn = NULL;
  static size_t fqn_size = 32;
  size_t str_size;
  char * dir;
  char * file;
  
  dir  = cca_strdup (param_dir);
  file = cca_strdup (param_file);
  
  if (!fqn)
    fqn = cca_malloc (fqn_size);
  
  str_size = strlen (dir) + 1 + strlen (file) + 1;
  
  if (str_size > fqn_size)
    {
      fqn_size = str_size;
      fqn = cca_realloc (fqn, fqn_size);
    }
  
  sprintf (fqn, "%s/%s", dir, file);
  
  free (dir);
  free (file);
  
  return fqn;
}

void
cca_create_dir (const char * dir)
{
  char * parent, * ptr;
  DIR * dirstream;
  struct stat parentstat;
  int err;
  
  dirstream = opendir (dir);
  if (dirstream)
    {
      closedir (dirstream);
      return;
    }
  
  if (errno == EACCES)
    {
      fprintf (stderr, "%s: warning: directory '%s' already exists, but we don't have permission to read it\n",
               __FUNCTION__, dir);
      return;
    }
  
  /* try and create the parent */
  parent = cca_strdup (dir);
  ptr = strrchr (parent, '/');
  if (ptr)
    *ptr = '\0';
  
  if (strlen (parent))
    cca_create_dir (parent);
  
  if (!strlen (parent))
    {
      ptr[0] = '/';
      ptr[1] = '\0';
    }  
  
  /* create our dir */
  /* stat parent */
  err = stat (parent, &parentstat);
  free (parent);
  if (err == -1)
    {
      fprintf (stderr, "%s: could not stat parent '%s' in order to create dir '%s': %s\n",
               __FUNCTION__, parent, dir, strerror (errno));
      return;
    }
  
  err = mkdir (dir, parentstat.st_mode);
  if (err == -1)
    fprintf (stderr, "%s: could not create directory '%s': %s\n", __FUNCTION__, dir, strerror (errno));
}

int
cca_dir_empty (const char * dir)
{
  DIR * dirstream;
  struct dirent * entry;
  int empty = 1;
  
  dirstream = opendir (dir);
  if (!dirstream)
    {
      fprintf (stderr, "%s: could not open directory '%s' to check emptiness; returning false for saftey: %s\n",
               __FUNCTION__, dir, strerror (errno));
      return 0;
    }
  
  while ( (entry = readdir (dirstream)) )
    {
      if (strcmp (entry->d_name, ".") == 0 ||
          strcmp (entry->d_name, "..") == 0)
        continue;
      
      empty = 0;
      break;
    }
  
  closedir (dirstream);
  return empty;
}

void
cca_remove_dir  (const char * dirarg)
{
  DIR * dirstream;
  struct dirent * entry;
  int err;
  const char * fqn;
  struct stat stat_info;
  char * dir;

  dir = cca_strdup (dirarg);
    
  dirstream = opendir (dir);
  if (!dirstream)
    {
      fprintf (stderr, "%s: could not open directory '%s' to remove it: %s\n",
               __FUNCTION__, dir, strerror (errno));
      free (dir);
      return;
    }
  
  while ( (entry = readdir (dirstream)) )
    {
      if (strcmp (entry->d_name, ".") == 0 ||
          strcmp (entry->d_name, "..") == 0)
        continue;
      
      fqn = cca_get_fqn (dir, entry->d_name);

      err = stat (fqn, &stat_info);
      if (err)
      {
        fprintf (stderr, "%s: could not stat file '%s': %s\n",
               __FUNCTION__, fqn, strerror (errno));
      }
      else
      {
        if (S_ISDIR(stat_info.st_mode))
          {
            cca_remove_dir (fqn);
            continue;
          }
      }
      
      err = unlink (fqn);
      if (err == -1)
        {
          fprintf (stderr, "%s: could not unlink file '%s': %s\n",
                   __FUNCTION__, fqn, strerror (errno));
          closedir (dirstream);
        free (dir);
          return;
        }
    }
  closedir (dirstream);
  
  err = rmdir (dir);
  if (err == -1)
    {
      fprintf (stderr, "%s: could not remove directroy '%s': %s\n",
               __FUNCTION__, dir, strerror (errno));
    }

  free (dir);
}


/* EOF */


Generated by  Doxygen 1.6.0   Back to index