/Users/huttone/Devel/sedflux-new/sedflux/trunk/ew/utils/eh_file_utils.c

Go to the documentation of this file.
00001 #include <eh_utils.h>
00002 
00003 FILE*
00004 eh_fopen(const char *filename, const char *type)
00005 {
00006    FILE *fp;
00007 
00008    eh_require( filename!=NULL );
00009 
00010    fp = fopen(filename,type);
00011    if ( !fp )
00012    {
00013       g_error( "eh_fopen: could not open file: %s" , filename );
00014       fp = NULL;
00015    }
00016 
00017    return fp;
00018 }
00019 
00020 #include <errno.h>
00021 
00022 gchar*
00023 eh_render_file_error_str( gint err_no )
00024 {
00025    gchar* err_str = NULL;
00026 
00027    if ( err_no!=0 )
00028    {
00029       GFileError file_error = g_file_error_from_errno( err_no );
00030 
00031       switch ( file_error )
00032       {
00033          case G_FILE_ERROR_EXIST:
00034             err_str = g_strdup( "Operation not permitted" ); break;
00035          case G_FILE_ERROR_ISDIR:
00036             err_str = g_strdup( "File is a directory" ); break;
00037          case G_FILE_ERROR_ACCES:
00038             err_str = g_strdup( "Permission denied" ); break;
00039          case G_FILE_ERROR_NAMETOOLONG:
00040             err_str = g_strdup( "Filename too long" ); break;
00041          case G_FILE_ERROR_NOENT:
00042             err_str = g_strdup( "No such file or directory" ); break;
00043          case G_FILE_ERROR_NOTDIR:
00044             err_str = g_strdup( "Not a directory" ); break;
00045          case G_FILE_ERROR_NXIO:
00046             err_str = g_strdup( "No such device or address" ); break;
00047          case G_FILE_ERROR_NODEV:
00048             err_str = g_strdup( "No such device" ); break;
00049          case G_FILE_ERROR_ROFS:
00050             err_str = g_strdup( "Read-only file system" ); break;
00051          case G_FILE_ERROR_TXTBSY:
00052             err_str = g_strdup( "Text file busy" ); break;
00053          case G_FILE_ERROR_FAULT:
00054             err_str = g_strdup( "Pointer to bad memory" ); break;
00055          case G_FILE_ERROR_LOOP:
00056             err_str = g_strdup( "Too many levels of symbolic links" ); break;
00057          case G_FILE_ERROR_NOSPC:
00058             err_str = g_strdup( "No space left on device" ); break;
00059          case G_FILE_ERROR_NOMEM:
00060             err_str = g_strdup( "No memory available" ); break;
00061          case G_FILE_ERROR_MFILE:
00062             err_str = g_strdup( "The current process has too many open files" ); break;
00063          case G_FILE_ERROR_NFILE:
00064             err_str = g_strdup( "The entire system has too many open files" ); break;
00065          case G_FILE_ERROR_BADF:
00066             err_str = g_strdup( "Bad file descriptor" ); break;
00067          case G_FILE_ERROR_INVAL:
00068             err_str = g_strdup( "Invalid argument" ); break;
00069          case G_FILE_ERROR_PIPE:
00070             err_str = g_strdup( "Broken pipe" ); break;
00071          case G_FILE_ERROR_AGAIN:
00072             err_str = g_strdup( "Resource temporarily unavailable" ); break;
00073          case G_FILE_ERROR_INTR:
00074             err_str = g_strdup( "Interrupted function call" ); break;
00075          case G_FILE_ERROR_IO:
00076             err_str = g_strdup( "Input/output error" ); break;
00077          case G_FILE_ERROR_PERM:
00078             err_str = g_strdup( "Output not permitted" ); break;
00079          case G_FILE_ERROR_NOSYS:
00080             err_str = g_strdup( "Function not implemented" ); break;
00081          case G_FILE_ERROR_FAILED:
00082             err_str = g_strdup( "Error unknown" ); break;
00083       }
00084    }
00085 
00086    return err_str;
00087 }
00088 
00089 FILE*
00090 eh_fopen_error( const char* file , const char* type , GError** error )
00091 {
00092    FILE*   fp = NULL;
00093 
00094    eh_return_val_if_fail( error==NULL || *error==NULL , NULL );
00095 
00096    fp = fopen( file , type );
00097 
00098    if ( !fp )
00099    {
00100       GError* tmp_err = NULL;
00101       eh_set_file_error_from_errno( &tmp_err , file , errno );
00102       g_propagate_error( error , tmp_err );
00103    }
00104 
00105    return fp;
00106 }
00107 
00108 void
00109 eh_set_file_error_from_errno( GError** error , const gchar* file , gint err_no )
00110 {
00111    if ( error )
00112    {
00113       eh_return_if_fail( *error==NULL );
00114 
00115       if ( err_no!=0 )
00116       {
00117          gchar* err_str = eh_render_file_error_str( err_no );
00118          if ( file )
00119             g_set_error( error ,
00120                          G_FILE_ERROR ,
00121                          g_file_error_from_errno(err_no) ,
00122                          "%s: %s" , file , err_str );
00123          else
00124             g_set_error( error ,
00125                          G_FILE_ERROR ,
00126                          g_file_error_from_errno(err_no) ,
00127                          "%s" , err_str );
00128          eh_free( err_str );
00129       }
00130    }
00131 
00132    return;
00133 }
00134 
00135 FILE*
00136 eh_open_file( const char *filename , const char *type )
00137 {
00138    FILE *fp;
00139    if ( filename )
00140       fp = eh_fopen( filename , type );
00141    else
00142       fp = stdin;
00143 
00144    return fp;
00145 }
00146 
00147 FILE*
00148 eh_open_temp_file( const char *template , char **name_used )
00149 {
00150    GError *error;
00151    int fd = g_file_open_tmp( template , name_used , &error );
00152    return fdopen( fd , "w+" );
00153 }
00154 
00155 #include <fcntl.h>
00156 #include <unistd.h>
00157 #include <errno.h>
00158 
00159 gboolean
00160 eh_is_readable_file( const char* filename )
00161 {
00162    FILE *fp = fopen( filename , "r" );
00163    if ( fp )
00164    {
00165       fclose(fp);
00166       return TRUE;
00167    }
00168    else
00169       return FALSE;
00170 }
00171 
00172 gboolean
00173 eh_is_writable_file( const char* filename )
00174 {
00175    FILE *fp = fopen( filename , "a" );
00176    if ( fp )
00177    {
00178       fclose(fp);
00179       return TRUE;
00180    }
00181    else
00182       return FALSE;
00183 }
00184 
00185 #include <glib/gstdio.h>
00186 
00187 gboolean
00188 eh_try_open( const char* file )
00189 {
00190    gboolean open_ok = FALSE;
00191 
00192    if ( file )
00193    {
00194       if ( g_file_test( file , G_FILE_TEST_EXISTS ) )
00195          open_ok = TRUE;
00196       else
00197       {
00198          char* dir = g_path_get_dirname( file );
00199 
00200          open_ok = eh_open_dir( dir , NULL );
00201 
00202          eh_free( dir );
00203       }
00204    }
00205 
00206    return open_ok;
00207 }
00208 
00209 gboolean
00210 eh_open_dir( const char* dir , GError** error )
00211 {
00212    gboolean open_ok = TRUE;
00213 
00214    eh_require( dir );
00215    eh_return_val_if_fail( error==NULL || *error==NULL , FALSE );
00216 
00217    if ( dir )
00218    {
00219       if ( g_mkdir_with_parents( dir , S_ISUID|S_ISGID|S_IRWXU|S_IRWXG )!=0 )
00220       {
00221          GError* tmp_err = NULL;
00222          eh_set_file_error_from_errno( &tmp_err , dir , errno );
00223          g_propagate_error( error , tmp_err );
00224          open_ok = FALSE;
00225       }
00226    }
00227 
00228    return open_ok;
00229 }
00230 
00231 gboolean
00232 try_open(const char *filename, int flags)
00233 {
00234    int fd = open(filename,flags,S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH);
00235    if ( fd < 0 )
00236    {
00237       fprintf(stderr,"warning : try_open : %s : %s\n",strerror(errno),filename);
00238       return FALSE;
00239    }
00240    else
00241    {
00242       close(fd);
00243       return TRUE;
00244    }
00245 }
00246 
00247 gboolean
00248 eh_touch_file( const gchar* file , int flags , GError** error )
00249 {
00250    gboolean is_ok = TRUE;
00251 
00252    eh_require( file );
00253    eh_return_val_if_fail( error==NULL || *error==NULL , FALSE );
00254 
00255    if ( file )
00256    {
00257       GError* tmp_err  = NULL;
00258       gchar*  dir_name = g_path_get_dirname( file );
00259 
00260       eh_open_dir( dir_name , &tmp_err );
00261 
00262       eh_free( dir_name );
00263 
00264       if ( !tmp_err )
00265       {
00266          gint fd = g_open( file , flags , S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH );
00267 
00268          if ( fd == -1 )
00269             eh_set_file_error_from_errno( &tmp_err , file , errno );
00270          else
00271             close( fd );
00272       }
00273 
00274       if ( tmp_err )
00275       {
00276          g_propagate_error( error , tmp_err );
00277          is_ok = FALSE;
00278       }
00279    }
00280    return is_ok;
00281 }
00282 
00283 #include <dirent.h>
00284 
00285 gboolean
00286 try_dir( const char *file , GError **error )
00287 {
00288    gboolean is_ok = FALSE;
00289    int      fd    = g_open(file,O_RDONLY);
00290 
00291    if ( fd < 0 )
00292    {
00293       GError* tmp_err = NULL;
00294       eh_set_file_error_from_errno( &tmp_err , file , errno );
00295       g_propagate_error( error , tmp_err );
00296       is_ok = FALSE;
00297    }
00298    else
00299    {
00300       close(fd);
00301       is_ok = TRUE;
00302    }
00303    return is_ok;
00304 }
00305 
00325 Eh_file_list*
00326 eh_create_file_list( char *base_name )
00327 {
00328    char **str_array;
00329    Eh_file_list *list;
00330 
00331    list = eh_new( Eh_file_list , 1 );
00332 
00333    str_array = g_strsplit( base_name , "#" , -1 );
00334    list->prefix = str_array[0];
00335    list->suffix = str_array[1];
00336    list->format = g_strdup("%04d");
00337    list->count  = 0;
00338 
00339    eh_free( str_array );
00340 
00341    return list;
00342 }
00343 
00352 gchar*
00353 eh_get_next_file( Eh_file_list *list )
00354 {
00355    char *new_file;
00356    char *count;
00357 
00358    count = g_strdup_printf( list->format , ++(list->count) );
00359    new_file = g_strconcat( list->prefix , count , list->suffix , NULL );
00360    eh_free( count );
00361    return new_file;
00362 }
00363 
00370 void
00371 eh_destroy_file_list( Eh_file_list *list )
00372 {
00373    if ( list )
00374    {
00375       eh_free( list->prefix );
00376       eh_free( list->suffix );
00377       eh_free( list->format );
00378       eh_free( list );
00379    }
00380 }
00381 

Generated on Fri Jan 4 18:04:16 2008 for sedflux by  doxygen 1.5.2