nonlib/file.C

   1
   2 /*******************************************************************************/
   3 /* Copyright (C) 2008 Jonathan Moore Liles                                     */
   4 /*                                                                             */
   5 /* This program is free software; you can redistribute it and/or modify it     */
   6 /* under the terms of the GNU General Public License as published by the       */
   7 /* Free Software Foundation; either version 2 of the License, or (at your      */
   8 /* option) any later version.                                                  */
   9 /*                                                                             */
  10 /* This program is distributed in the hope that it will be useful, but WITHOUT */
  11 /* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       */
  12 /* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for   */
  13 /* more details.                                                               */
  14 /*                                                                             */
  15 /* You should have received a copy of the GNU General Public License along     */
  16 /* with This program; see the file COPYING.  If not,write to the Free Software */
  17 /* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  18 /*******************************************************************************/
  19
  20 #include <fcntl.h>
  21 #include <sys/stat.h>
  22 #include <sys/types.h>
  23 #include <unistd.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #include <sys/vfs.h>
  28
  29 unsigned long
  30 modification_time ( const char *file )
  31 {
  32     struct stat st;
  33
  34     if ( stat( file, &st ) )
  35         return 0;
  36
  37     return st.st_mtime;
  38 }
  39
  40 /** returns /true/ if /file1/ is newer than /file2/ (or file2 doesn't exist) */
  41 bool
  42 newer ( const char *file1, const char *file2 )
  43 {
  44     return modification_time( file1 ) > modification_time( file2 );
  45 }
  46
  47 unsigned long
  48 size ( const char *file )
  49 {
  50     struct stat st;
  51
  52     if ( stat( file, &st ) )
  53         return 0;
  54
  55     return st.st_size;
  56 }
  57
  58 int
  59 exists ( const char *name )
  60 {
  61     struct stat st;
  62
  63     return 0 == stat( name, &st );
  64 }
  65
  66 bool
  67 acquire_lock ( int *lockfd, const char *filename )
  68 {
  69     struct flock fl;
  70
  71     fl.l_type = F_WRLCK;
  72     fl.l_whence = SEEK_SET;
  73     fl.l_start = 0;
  74     fl.l_len = 0;
  75
  76     *lockfd = ::creat( filename, 0777 );
  77
  78     if ( fcntl( *lockfd, F_SETLK, &fl ) != 0 )
  79         return false;
  80
  81     return true;
  82 }
  83
  84 void
  85 release_lock ( int *lockfd, const char *filename )
  86 {
  87     unlink( filename );
  88
  89     ::close( *lockfd );
  90
  91     *lockfd = 0;
  92 }
  93
  94 int
  95 backwards_fgetc ( FILE *fp )
  96 {
  97     int c;
  98
  99     if ( fseek( fp, -1, SEEK_CUR ) != 0 )
 100         return -1;
 101
 102     c = fgetc( fp );
 103
 104     fseek( fp, -1, SEEK_CUR );
 105
 106     return c;
 107 }
 108
 109 char *
 110 backwards_fgets ( char *s, int size, FILE *fp )
 111 {
 112     if ( fseek( fp, -1, SEEK_CUR ) != 0 )
 113         return NULL;
 114
 115     int c;
 116     while ( ( c = backwards_fgetc( fp ) ) >= 0 )
 117         if ( '\n' == c )
 118             break;
 119
 120     long here = ftell( fp );
 121
 122     fseek( fp, 1, SEEK_CUR );
 123
 124     char *r = fgets( s, size, fp );
 125
 126     fseek( fp, here, SEEK_SET );
 127
 128     return r;
 129 }
 130
 131
 132 /** update the modification time of file referred to by /fd/ */
 133 void
 134 touch ( int fd )
 135 {
 136     struct stat st;
 137
 138     fstat( fd, &st );
 139
 140     fchmod( fd, st.st_mode );
 141 }
 142
 143 /** write a single string to a file */
 144 void
 145 write_line ( const char *dir, const char *name, const char *value )
 146 {
 147     char path[512];
 148
 149     snprintf( path, sizeof( path ), "%s/%s", dir, name );
 150
 151     FILE *fp = fopen( path, "w" );
 152
 153     if ( ! fp )
 154         return;
 155
 156     fputs( value, fp );
 157
 158     fclose( fp );
 159 }
 160
 161 /** write a single string to a file */
 162 void
 163 read_line ( const char *dir, const char *name, char **value )
 164 {
 165     char path[512];
 166
 167     *value = 0;
 168
 169     snprintf( path, sizeof( path ), "%s/%s", dir, name );
 170
 171     FILE *fp = fopen( path, "r" );
 172
 173     if ( ! fp )
 174         return;
 175
 176     *value = (char*)malloc( 512 );
 177
 178     fgets( *value, 512, fp );
 179
 180     fclose( fp );
 181 }
 182
 183 #include <sys/statvfs.h>
 184
 185 /** return the number of blocks free on filesystem containing file named /file/ */
 186 fsblkcnt_t
 187 free_space ( const char *file )
 188 {
 189     struct statfs st;
 190     memset( &st, 0, sizeof( st ) );
 191
 192     statfs( file, &st );
 193
 194     return st.f_bavail;
 195 }
 196
 197 /** return the total number of blocks on filesystem containing file named /file/ */
 198 fsblkcnt_t
 199 total_space ( const char *file )
 200 {
 201     struct statfs st;
 202     memset( &st, 0, sizeof( st ) );
 203
 204     statfs( file, &st );
 205
 206     return st.f_blocks;
 207 }
 208
 209 /** return the percentage of usage on filesystem containing file named /file/ */
 210 int
 211 percent_used ( const char *file )
 212 {
 213     const double ts = total_space( file );
 214     const double fs = free_space( file );
 215
 216     double percent_free = ( ( fs / ts ) * 100.0f );
 217
 218     return (int) (100.0f - percent_free);
 219 }