Add support for logging to a specified file
authorSteve McIntyre <steve@einval.com>
Wed, 19 Jan 2011 02:09:23 +0000 (02:09 +0000)
committerSteve McIntyre <steve@einval.com>
Wed, 19 Jan 2011 02:09:23 +0000 (02:09 +0000)
Will attempt to log to stderr by default, but that gets eaten by the
FUSE library code unless running with -d. Specifying --logfile <foo>
will send all the fs debug to <foo>. If used with -d as well, the FUSE
debug output will go there too.

C/fmcache.c
C/fmdb.c
C/fuse-music.c
C/misc.c
C/misc.h

index 78f1827..e1464cd 100644 (file)
@@ -78,7 +78,7 @@ static int cache_remove_lru(void)
     if (error)
     {
         pthread_mutex_unlock(&cache_db_mutex);
-        fprintf(stderr, "%s: failed to find LRU entry, error %d\n",
+        fprintf(logfile, "%s: failed to find LRU entry, error %d\n",
                 __func__, error);
         return error;
     }
@@ -87,7 +87,7 @@ static int cache_remove_lru(void)
     error = unlink(cache_file);
     if (error)
     {
-        fprintf(stderr, "%s: unable to delete cache file %s, error %d\n",
+        fprintf(logfile, "%s: unable to delete cache file %s, error %d\n",
                 __func__, cache_file, errno);
         pthread_mutex_unlock(&cache_db_mutex);
         return errno;
@@ -96,7 +96,7 @@ static int cache_remove_lru(void)
     error = db_remove_cache_entry(dbp, &entry);
     if (error)
     {
-        fprintf(stderr, "%s: failed to delete cache DB entry for %s, error %d\n",
+        fprintf(logfile, "%s: failed to delete cache DB entry for %s, error %d\n",
                 __func__, cache_file, error);
         pthread_mutex_unlock(&cache_db_mutex);
         return error;
@@ -143,14 +143,14 @@ char *cache_allocate(const char *basedir, const char *flac_path, unsigned long l
         fd = open(cache_full_path, O_WRONLY|O_CREAT|O_EXCL, 0600);
         if (-1 == fd)
         {
-            fprintf(stderr, "%s: allocated space for cache OK, but error %d opening cache file %s\n",
+            fprintf(logfile, "%s: allocated space for cache OK, but error %d opening cache file %s\n",
                     __func__, errno, cache_full_path);
             free(cache_file_name);
         }
         else
             file_name_available = 1;
     }
-    fprintf(stderr, "%s: allocated and created cache file OK: %s\n", __func__, cache_full_path);
+    fprintf(logfile, "%s: allocated and created cache file OK: %s\n", __func__, cache_full_path);
     close(fd);
 
     strncpy(cache_entry.flac_path, strip_leading_path(flac_path, basedir), sizeof(cache_entry.flac_path));
@@ -180,7 +180,7 @@ int cache_entry_encode_complete(const char *cache_file_name, unsigned long long
     error = db_lookup_cache_entry_by_cache_path(dbp, &in, &out);
     if (error)
     {
-        fprintf(stderr, "%s: failed to find previous entry to match cache file %s\n",
+        fprintf(logfile, "%s: failed to find previous entry to match cache file %s\n",
                 __func__, cache_file_name);
         pthread_mutex_unlock(&cache_db_mutex);
         return error;
@@ -192,7 +192,7 @@ int cache_entry_encode_complete(const char *cache_file_name, unsigned long long
     error = db_store_cache_entry(dbp, &out);
     if (error)
     {
-        fprintf(stderr, "%s: failed to store replacement entry for cache file %s\n",
+        fprintf(logfile, "%s: failed to store replacement entry for cache file %s\n",
                 __func__, cache_file_name);
         pthread_mutex_unlock(&cache_db_mutex);
         return error;
@@ -219,7 +219,7 @@ int cache_entry_failed(const char *cache_file_name)
     error = db_lookup_cache_entry_by_cache_path(dbp, &in, &out);
     if (error)
     {
-        fprintf(stderr, "%s: failed to find previous entry to match cache file %s\n",
+        fprintf(logfile, "%s: failed to find previous entry to match cache file %s\n",
                 __func__, cache_file_name);
         pthread_mutex_unlock(&cache_db_mutex);
         return error;
@@ -232,7 +232,7 @@ int cache_entry_failed(const char *cache_file_name)
     error = db_remove_cache_entry(dbp, &out);
     if (error)
     {
-        fprintf(stderr, "%s: failed to remove entry for cache file %s\n",
+        fprintf(logfile, "%s: failed to remove entry for cache file %s\n",
                 __func__, cache_file_name);
         pthread_mutex_unlock(&cache_db_mutex);
         return error;
@@ -244,7 +244,7 @@ int cache_entry_failed(const char *cache_file_name)
     error = unlink(cache_path);
     if (error)
     {
-        fprintf(stderr, "%s: unable to delete cache file %s, error %d\n",
+        fprintf(logfile, "%s: unable to delete cache file %s, error %d\n",
                 __func__, cache_path, errno);
         return errno;
     }    
@@ -265,7 +265,7 @@ char *cache_lookup_for_read(const char *basedir, const char *flac_path)
     error = db_lookup_cache_entry_by_flac_path(dbp, &in, &out);
     if (error)
     {
-        fprintf(stderr, "%s: failed to find previous entry to match flac_path %s\n",
+        fprintf(logfile, "%s: failed to find previous entry to match flac_path %s\n",
                 __func__, in.flac_path);
         pthread_mutex_unlock(&cache_db_mutex);
         return NULL;
@@ -276,11 +276,11 @@ char *cache_lookup_for_read(const char *basedir, const char *flac_path)
     error = db_store_cache_entry(dbp, &out);
     if (error)
     {
-        fprintf(stderr, "%s: failed to store replacement entry for flac_path %s\n",
+        fprintf(logfile, "%s: failed to store replacement entry for flac_path %s\n",
                 __func__, in.flac_path);
     }
     pthread_mutex_unlock(&cache_db_mutex);
-    fprintf(stderr, "%s: starting to read from cache file %s\n", __func__, out.cache_path);
+    fprintf(logfile, "%s: starting to read from cache file %s\n", __func__, out.cache_path);
     return strdup(out.cache_path);
 }
 
@@ -297,7 +297,7 @@ int cache_read_finished(const char *basedir, const char *flac_path)
     error = db_lookup_cache_entry_by_flac_path(dbp, &in, &out);
     if (error)
     {
-        fprintf(stderr, "%s: failed to find previous entry to match flac_path %s\n",
+        fprintf(logfile, "%s: failed to find previous entry to match flac_path %s\n",
                 __func__, in.flac_path);
         pthread_mutex_unlock(&cache_db_mutex);
         return ENOENT;
@@ -308,11 +308,11 @@ int cache_read_finished(const char *basedir, const char *flac_path)
     error = db_store_cache_entry(dbp, &out);
     if (error)
     {
-        fprintf(stderr, "%s: failed to store replacement entry for flac_path %s\n",
+        fprintf(logfile, "%s: failed to store replacement entry for flac_path %s\n",
                 __func__, in.flac_path);
     }
     pthread_mutex_unlock(&cache_db_mutex);
-    fprintf(stderr, "%s: finished reading from cache file %s\n", __func__, out.cache_path);
+    fprintf(logfile, "%s: finished reading from cache file %s\n", __func__, out.cache_path);
     return 0;
 }
 
@@ -350,15 +350,15 @@ int cache_init(FMDB *db_state, char *dir, unsigned long long max_size)
             error = mkdir(cache_dir, 0700);
             if (error)
             {
-                fprintf(stderr, "%s: can't create a new cache_dir %s: error %d (%s)\n",
+                fprintf(logfile, "%s: can't create a new cache_dir %s: error %d (%s)\n",
                         __func__, cache_dir, errno, strerror(errno));
                 return errno;
             }
-            fprintf(stderr, "%s: Created new cache_dir %s\n", __func__, cache_dir);
+            fprintf(logfile, "%s: Created new cache_dir %s\n", __func__, cache_dir);
         }
         else
         {
-            fprintf(stderr, "%s: can't stat cache_dir %s, error %d (%s)\n",
+            fprintf(logfile, "%s: can't stat cache_dir %s, error %d (%s)\n",
                     __func__, cache_dir, errno, strerror(errno));
             return errno;
         }
@@ -367,7 +367,7 @@ int cache_init(FMDB *db_state, char *dir, unsigned long long max_size)
     randomfd = open(RANDOM_FILE, O_RDONLY);
     if (-1 == randomfd)
     {
-        fprintf(stderr, "%s: can't open random file %s, error %d\n", 
+        fprintf(logfile, "%s: can't open random file %s, error %d\n", 
                 __func__, RANDOM_FILE, errno);
         return errno;
     }
@@ -378,14 +378,14 @@ int cache_init(FMDB *db_state, char *dir, unsigned long long max_size)
     if (error)
         return error;
 
-    fprintf(stderr, "%s: Checking existing cache files\n", __func__);
+    fprintf(logfile, "%s: Checking existing cache files\n", __func__);
     /* Now we've walked through all the DB entries and deleted any
      * dodgy ones, let's see what's left on disk. If we find a cache
      * file with no associated DB entry, delete it. */
     dp = opendir(cache_dir);
     if (dp == NULL)
     {
-        fprintf(stderr, "%s: can't open cache_dir, error %d\n", __func__, errno);
+        fprintf(logfile, "%s: can't open cache_dir, error %d\n", __func__, errno);
         return errno;
     }
 
@@ -399,7 +399,7 @@ int cache_init(FMDB *db_state, char *dir, unsigned long long max_size)
         error = stat(cache_file_name, &sb);
         if (error)
         {
-            fprintf(stderr, "%s: unable to stat cache file %s, error %d. Deleting\n",
+            fprintf(logfile, "%s: unable to stat cache file %s, error %d. Deleting\n",
                     __func__, cache_file_name, error);
             removed_cache_entries++;
             unlink(cache_file_name);
@@ -410,7 +410,7 @@ int cache_init(FMDB *db_state, char *dir, unsigned long long max_size)
             error = db_lookup_cache_entry_by_cache_path(dbp, &in, &out);
             if (error)
             {
-                fprintf(stderr, "%s: error looking up cache file %s in the DB, error %d. Deleting\n",
+                fprintf(logfile, "%s: error looking up cache file %s in the DB, error %d. Deleting\n",
                         __func__, cache_file_name, error);
                 removed_cache_entries++;
                 unlink(cache_file_name);
@@ -423,20 +423,20 @@ int cache_init(FMDB *db_state, char *dir, unsigned long long max_size)
         }
     }
     closedir(dp);
-    fprintf(stderr, "%s: statistics:\n", __func__);
-    fprintf(stderr, "  found %d cache files at startup\n", startup_cache_files);
-    fprintf(stderr, "  cleaned up %d cache files\n", removed_cache_entries);
-    fprintf(stderr, "  now have %d cache files\n", startup_cache_files - removed_cache_entries);
-    fprintf(stderr, "  using %lld bytes of space for cache files against max of %lld\n",
+    fprintf(logfile, "%s: statistics:\n", __func__);
+    fprintf(logfile, "  found %d cache files at startup\n", startup_cache_files);
+    fprintf(logfile, "  cleaned up %d cache files\n", removed_cache_entries);
+    fprintf(logfile, "  now have %d cache files\n", startup_cache_files - removed_cache_entries);
+    fprintf(logfile, "  using %lld bytes of space for cache files against max of %lld\n",
             cache_space_used, cache_max_size);
 
     if (cache_space_used > cache_max_size)
     {
-        fprintf(stderr, "%s: using too much cache space (%lld, configured for %lld). Removing files\n",
+        fprintf(logfile, "%s: using too much cache space (%lld, configured for %lld). Removing files\n",
                 __func__, cache_space_used, cache_max_size);
         while (cache_space_used > cache_max_size)
             cache_remove_lru();
-        fprintf(stderr, "%s: Now down to a valid size; (%lld, configured for %lld). Removing files\n",
+        fprintf(logfile, "%s: Now down to a valid size; (%lld, configured for %lld). Removing files\n",
                 __func__, cache_space_used, cache_max_size);
     }
 
index 13ce8ac..313e56c 100644 (file)
--- a/C/fmdb.c
+++ b/C/fmdb.c
@@ -8,6 +8,7 @@
 #include <unistd.h>
 #include <dirent.h>
 #include "fmdb.h"
+#include "misc.h"
 
 typedef struct
 {
@@ -70,7 +71,7 @@ static int db_create_size_table(db_state_t *dbp)
     error = sqlite3_exec(dbp->db, sql_command, NULL, NULL, &open_error);
     if (error)
     {
-        fprintf(stderr, "%s: got error %d (%s) from create\n",
+        fprintf(logfile, "%s: got error %d (%s) from create\n",
                 __func__, error, open_error);
         if (open_error)
             sqlite3_free(open_error);
@@ -96,7 +97,7 @@ static int db_create_cache_table(db_state_t *dbp)
     error = sqlite3_exec(dbp->db, sql_command, NULL, NULL, &open_error);
     if (error)
     {
-        fprintf(stderr, "%s: got error %d (%s) from create\n",
+        fprintf(logfile, "%s: got error %d (%s) from create\n",
                 __func__, error, open_error);
         if (open_error)
             sqlite3_free(open_error);
@@ -179,15 +180,15 @@ int db_store_size_entry(FMDB *dbp, const db_size_entry_t *in)
     error = sqlite3_exec(state->db, sql_command, NULL, NULL, &open_error);
     if (error)
     {
-        fprintf(stderr, "%s: Failed to remove old entry for %s, error %d (%s)\n",
+        fprintf(logfile, "%s: Failed to remove old entry for %s, error %d (%s)\n",
                 __func__, in->flac_path, error, open_error);
         if (open_error)
             sqlite3_free(open_error);
     }
     else
-        fprintf(stderr, "%s: Deleted old entry for %s\n", __func__, in->flac_path);
+        fprintf(logfile, "%s: Deleted old entry for %s\n", __func__, in->flac_path);
 
-    fprintf(stderr, "%s: storing %s:%s:%s:%lld:%ld\n",
+    fprintf(logfile, "%s: storing %s:%s:%s:%lld:%ld\n",
             __func__, in->flac_path, in->format_choice, in->format_quality,
             in->size, in->mtime);            
     sprintf(sql_command, "INSERT INTO sizes VALUES('%s','%s','%s',%lld,%ld);",
@@ -196,7 +197,7 @@ int db_store_size_entry(FMDB *dbp, const db_size_entry_t *in)
     error = sqlite3_exec(state->db, sql_command, NULL, NULL, &open_error);
     if (error)
     {
-        fprintf(stderr, "%s: Failed to write entry, error %d (%s)\n",
+        fprintf(logfile, "%s: Failed to write entry, error %d (%s)\n",
                 __func__, error, open_error);
         if (open_error)
             sqlite3_free(open_error);
@@ -221,7 +222,7 @@ int db_lookup_size_entry(FMDB *dbp, const db_size_entry_t *in, db_size_entry_t *
     error = sqlite3_exec(state->db, sql_command, results_callback, &result_type, &open_error);
     if (error)
     {
-        fprintf(stderr, "%s: Failed to lookup, error %d (%s)\n", __func__, error, open_error);
+        fprintf(logfile, "%s: Failed to lookup, error %d (%s)\n", __func__, error, open_error);
         if (open_error)
             sqlite3_free(open_error);
         return error;
@@ -232,7 +233,7 @@ int db_lookup_size_entry(FMDB *dbp, const db_size_entry_t *in, db_size_entry_t *
     {
         memcpy(out, &res_current->data.size, sizeof(db_size_entry_t));
         res_current = res_current->next;
-        fprintf(stderr, "%s: copying %s:%s:%s:%lld:%ld\n",
+        fprintf(logfile, "%s: copying %s:%s:%s:%lld:%ld\n",
                 __func__, out->flac_path, out->format_choice, out->format_quality,
                 out->size, out->mtime);
     }
@@ -255,7 +256,7 @@ int db_remove_size_entry(FMDB *dbp, const db_size_entry_t *in)
     error = sqlite3_exec(state->db, sql_command, NULL, NULL, &open_error);
     if (error)
     {
-        fprintf(stderr, "%s: Failed to remove, error %d (%s)\n",
+        fprintf(logfile, "%s: Failed to remove, error %d (%s)\n",
                 __func__, error, open_error);
         if (open_error)
             sqlite3_free(open_error);
@@ -277,16 +278,16 @@ int db_store_cache_entry(FMDB *dbp, const db_cache_entry_t *in)
     error = sqlite3_exec(state->db, sql_command, NULL, NULL, &open_error);
     if (error)
     {
-        fprintf(stderr, "%s: Failed to remove old entry for %s, error %d (%s)\n",
+        fprintf(logfile, "%s: Failed to remove old entry for %s, error %d (%s)\n",
                 __func__, in->flac_path, error, open_error);
         if (open_error)
             sqlite3_free(open_error);
     }
     else
-        fprintf(stderr, "%s: Deleted old entry for %s\n", __func__, in->flac_path);
+        fprintf(logfile, "%s: Deleted old entry for %s\n", __func__, in->flac_path);
 
     /* Now write the new entry */
-    fprintf(stderr, "%s: storing %s:%s:%s:%lld:%ld\n",
+    fprintf(logfile, "%s: storing %s:%s:%s:%lld:%ld\n",
             __func__, in->flac_path, in->cache_path, str_state(in->state),
             in->size, in->mtime);            
     sprintf(sql_command, "INSERT INTO cache VALUES('%s','%s',%d,%lld,%ld);",
@@ -295,7 +296,7 @@ int db_store_cache_entry(FMDB *dbp, const db_cache_entry_t *in)
     error = sqlite3_exec(state->db, sql_command, NULL, NULL, &open_error);
     if (error)
     {
-        fprintf(stderr, "%s: Failed to write entry, error %d (%s)\n",
+        fprintf(logfile, "%s: Failed to write entry, error %d (%s)\n",
                 __func__, error, open_error);
         if (open_error)
             sqlite3_free(open_error);
@@ -320,7 +321,7 @@ int db_lookup_cache_entry_by_flac_path(FMDB *dbp, const db_cache_entry_t *in, db
     error = sqlite3_exec(state->db, sql_command, results_callback, &result_type, &open_error);
     if (error)
     {
-        fprintf(stderr, "%s: Failed to lookup, error %d (%s)\n",
+        fprintf(logfile, "%s: Failed to lookup, error %d (%s)\n",
                 __func__, error, open_error);
         if (open_error)
             sqlite3_free(open_error);
@@ -332,7 +333,7 @@ int db_lookup_cache_entry_by_flac_path(FMDB *dbp, const db_cache_entry_t *in, db
     {
         memcpy(out, &res_current->data.cache, sizeof(db_cache_entry_t));
         res_current = res_current->next;
-        fprintf(stderr, "%s: copying %s:%s:%d:%lld:%ld\n",
+        fprintf(logfile, "%s: copying %s:%s:%d:%lld:%ld\n",
                 __func__, out->flac_path, out->cache_path, out->state,
                 out->size, out->mtime);
     }
@@ -358,7 +359,7 @@ int db_lookup_cache_entry_by_cache_path(FMDB *dbp, const db_cache_entry_t *in, d
     error = sqlite3_exec(state->db, sql_command, results_callback, &result_type, &open_error);
     if (error)
     {
-        fprintf(stderr, "%s: Failed to lookup, error %d (%s)\n",
+        fprintf(logfile, "%s: Failed to lookup, error %d (%s)\n",
                 __func__, error, open_error);
         if (open_error)
             sqlite3_free(open_error);
@@ -370,7 +371,7 @@ int db_lookup_cache_entry_by_cache_path(FMDB *dbp, const db_cache_entry_t *in, d
     {
         memcpy(out, &res_current->data.cache, sizeof(db_cache_entry_t));
         res_current = res_current->next;
-        fprintf(stderr, "%s: copying %s:%s:%d:%lld:%ld\n",
+        fprintf(logfile, "%s: copying %s:%s:%d:%lld:%ld\n",
                 __func__, out->flac_path, out->cache_path, out->state,
                 out->size, out->mtime);
     }
@@ -396,7 +397,7 @@ int db_lookup_cache_entry_by_lru(FMDB *dbp, db_cache_entry_t *out)
     error = sqlite3_exec(state->db, sql_command, results_callback, &result_type, &open_error);
     if (error)
     {
-        fprintf(stderr, "%s: Failed to lookup, error %d (%s)\n",
+        fprintf(logfile, "%s: Failed to lookup, error %d (%s)\n",
                 __func__, error, open_error);
         if (open_error)
             sqlite3_free(open_error);
@@ -408,7 +409,7 @@ int db_lookup_cache_entry_by_lru(FMDB *dbp, db_cache_entry_t *out)
     {
         memcpy(out, &res_current->data.cache, sizeof(db_cache_entry_t));
         res_current = res_current->next;
-        fprintf(stderr, "%s: copying %s:%s:%d:%lld:%ld\n",
+        fprintf(logfile, "%s: copying %s:%s:%d:%lld:%ld\n",
                 __func__, out->flac_path, out->cache_path, out->state,
                 out->size, out->mtime);
     }
@@ -431,7 +432,7 @@ int db_remove_cache_entry(FMDB *dbp, const db_cache_entry_t *in)
     error = sqlite3_exec(state->db, sql_command, NULL, NULL, &open_error);
     if (error)
     {
-        fprintf(stderr, "%s: Failed to remove, error %d (%s)\n",
+        fprintf(logfile, "%s: Failed to remove, error %d (%s)\n",
                 __func__, error, open_error);
         if (open_error)
             sqlite3_free(open_error);
@@ -452,13 +453,13 @@ int sync_cache_and_db(FMDB *dbp, char *cache_dir)
 
     /* First, check that all the entries in the DB exist on disk; any
      * that don't, or that look wrong: delete the DB entry */
-    fprintf(stderr, "%s: Checking DB entry sanity\n", __func__);
+    fprintf(logfile, "%s: Checking DB entry sanity\n", __func__);
     free_results();
     sprintf(sql_command, "SELECT * FROM cache;");
     error = sqlite3_exec(state->db, sql_command, results_callback, &result_type, &open_error);
     if (error)
     {
-        fprintf(stderr, "%s: Failed to lookup results, error %d (%s)\n",
+        fprintf(logfile, "%s: Failed to lookup results, error %d (%s)\n",
                 __func__, error, open_error);
         if (open_error)
             sqlite3_free(open_error);
@@ -492,7 +493,7 @@ int sync_cache_and_db(FMDB *dbp, char *cache_dir)
                 error = db_store_cache_entry(dbp, entry);
                 if (error)
                 {
-                    fprintf(stderr, "%s: can't update cache DB entry for %s; error %d\n",
+                    fprintf(logfile, "%s: can't update cache DB entry for %s; error %d\n",
                             __func__, entry->cache_path, error);
                     return error;
                 }
@@ -504,7 +505,7 @@ int sync_cache_and_db(FMDB *dbp, char *cache_dir)
             error = stat(cache_file_name, &sb);
             if (error)
             {
-                fprintf(stderr, "%s: can't stat cache file %s, error %d. Deleting DB entry\n",
+                fprintf(logfile, "%s: can't stat cache file %s, error %d. Deleting DB entry\n",
                         __func__, cache_file_name, errno);
                 db_remove_cache_entry(dbp, entry);
                 removed_db_entries++;
@@ -513,7 +514,7 @@ int sync_cache_and_db(FMDB *dbp, char *cache_dir)
             {
                 if (sb.st_size != entry->size)
                 {
-                    fprintf(stderr, "%s: cache file %s is wrong size (%lld bytes, DB said %lld). Deleting DB entry\n",
+                    fprintf(logfile, "%s: cache file %s is wrong size (%lld bytes, DB said %lld). Deleting DB entry\n",
                             __func__, cache_file_name, (unsigned long long)sb.st_size, entry->size);
                     db_remove_cache_entry(dbp, entry);
                     removed_db_entries++;
@@ -524,10 +525,10 @@ int sync_cache_and_db(FMDB *dbp, char *cache_dir)
         res_current = res_current->next;
     }
     free_results();
-    fprintf(stderr, "%s: statistics:\n", __func__);
-    fprintf(stderr, "  found %d cache DB entries at startup\n", startup_db_entries);
-    fprintf(stderr, "  cleaned up %d cache DB entries\n", removed_db_entries);
-    fprintf(stderr, "  now have %d cache DB entries\n", startup_db_entries - removed_db_entries);
+    fprintf(logfile, "%s: statistics:\n", __func__);
+    fprintf(logfile, "  found %d cache DB entries at startup\n", startup_db_entries);
+    fprintf(logfile, "  cleaned up %d cache DB entries\n", removed_db_entries);
+    fprintf(logfile, "  now have %d cache DB entries\n", startup_db_entries - removed_db_entries);
     return 0;
 }
 
@@ -543,7 +544,7 @@ FMDB *db_open(char *db_name)
         error = sqlite3_open(db_name, &dbp->db);
         if (error)
         {
-            fprintf(stderr, "%s: Unable to open sqlite file %s: error %d\n", __func__, db_name, error);
+            fprintf(logfile, "%s: Unable to open sqlite file %s: error %d\n", __func__, db_name, error);
             errno = error;
             return NULL;
         }
index 14fb259..7aa11ee 100644 (file)
@@ -19,6 +19,8 @@
 #include <fuse.h>
 #include <fuse_opt.h>
 
+FILE *logfile = NULL;
+
 typedef enum
 {
     OUTFMT_OGG = 0,
@@ -60,6 +62,7 @@ struct mount_opts
     char *db_file;
     char *format;
     char *quality;
+    char *logfile;
 };
 
 struct mount_opts mo;
@@ -73,6 +76,7 @@ static const struct fuse_opt fm_mount_opts[] = {
     FUSE_MOUNT_OPT("--db=%s",            db_file),
     FUSE_MOUNT_OPT("--format=%s",        format),
     FUSE_MOUNT_OPT("--quality=%s",       quality),
+    FUSE_MOUNT_OPT("--logfile=%s",       logfile),
     FUSE_OPT_END
 };
 
@@ -83,7 +87,7 @@ static char *convert_to_base_path(const char *path)
     char *out = NULL;
     int ret = 0;
 
-    fprintf(stderr, "%s: path %s, mo.basedir %s\n", __func__, path, mo.basedir);
+    fprintf(logfile, "%s: path %s, mo.basedir %s\n", __func__, path, mo.basedir);
     
     if (!basename)
         return NULL;
@@ -150,10 +154,10 @@ static int call_encoder(const char *flac_path, const char *cache_path)
     if (-1 == error)
         return ENOMEM;
         
-    fprintf(stderr, "%s: Ready to run:\n", __func__);
-    fprintf(stderr, command);
+    fprintf(logfile, "%s: Ready to run:\n", __func__);
+    fprintf(logfile, command);
     error = system(command);
-    fprintf(stderr, "%s: system() returned %d\n", __func__, error);
+    fprintf(logfile, "%s: system() returned %d\n", __func__, error);
     return 0;
 }
 
@@ -172,7 +176,7 @@ static int encode_file(const char *flac_path)
     cache_file_name = cache_allocate(mo.basedir, flac_path, flac_size);
     if (!cache_file_name)
     {
-        fprintf(stderr, "%s: unable to allocate %lld bytes for a file in the cache, error %d\n",
+        fprintf(logfile, "%s: unable to allocate %lld bytes for a file in the cache, error %d\n",
                 __func__, flac_size, errno);
         return errno;
     }
@@ -181,7 +185,7 @@ static int encode_file(const char *flac_path)
     error = call_encoder(flac_path, cache_path);
     if (error)
     {
-        fprintf(stderr, "%s: encoding failed, error %d\n", __func__, error);
+        fprintf(logfile, "%s: encoding failed, error %d\n", __func__, error);
         cache_entry_failed(cache_file_name);
         free(cache_file_name);
         return error;
@@ -196,7 +200,7 @@ static int encode_file(const char *flac_path)
     error = db_store_size_entry(db_state, &size_entry);
     if (error)
     {
-        fprintf(stderr, "%s: unable to store size entry for %s, error %d\n",
+        fprintf(logfile, "%s: unable to store size entry for %s, error %d\n",
                 __func__, flac_path, error);
         cache_entry_failed(cache_file_name);
         free(cache_file_name);
@@ -206,7 +210,7 @@ static int encode_file(const char *flac_path)
     error = cache_entry_encode_complete(cache_file_name, file_size(cache_path));
     if (error)
     {
-        fprintf(stderr, "%s: unable to update cache DB entry for %s, error %d\n",
+        fprintf(logfile, "%s: unable to update cache DB entry for %s, error %d\n",
                 __func__, flac_path, error);
         cache_entry_failed(cache_file_name);
         free(cache_file_name);
@@ -231,12 +235,12 @@ static size_t encoded_size(const char *flac_path)
     error = db_lookup_size_entry(db_state, &in, &out);
     if (error)
     {
-        fprintf(stderr, "%s: returned error %d for %s\n", __func__, error, flac_path);
+        fprintf(logfile, "%s: returned error %d for %s\n", __func__, error, flac_path);
         need_to_encode = 1;
     }
     else if (mtime > out.mtime)
     {
-        fprintf(stderr, "%s: file is newer than cached size entry (%ld > %ld) for %s; re-encode\n",
+        fprintf(logfile, "%s: file is newer than cached size entry (%ld > %ld) for %s; re-encode\n",
                 __func__, mtime, out.mtime, flac_path);
         need_to_encode = 1;
     }
@@ -254,7 +258,7 @@ static size_t encoded_size(const char *flac_path)
     error = db_lookup_size_entry(db_state, &in, &out);
     if (error)
     {
-        fprintf(stderr, "%s: returned error %d for %s after an encode attempt!\n",
+        fprintf(logfile, "%s: returned error %d for %s after an encode attempt!\n",
                 __func__, error, flac_path);
         return -1;
     }
@@ -324,7 +328,7 @@ static int fm_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
     (void) offset;
     (void) fi;
 
-    fprintf(stderr, "%s: readdir %s\n", __func__, path);
+    fprintf(logfile, "%s: readdir %s\n", __func__, path);
 
     flac_path = convert_to_base_path(path);
     if (!flac_path)
@@ -487,40 +491,55 @@ static struct fuse_operations fm_oper = {
 
 int main(int argc, char *argv[])
 {
-    umask(0);
     int i = 0;
     int error = 0;
     struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
-    for (i = 0; i < argc; i++)
-        fprintf(stderr, "argv[%d]: %s\n", i, argv[i]);
+
+    umask(0);
+
+    logfile = stderr;
 
     mo.cachesize = CACHE_DEFAULT_SIZE;
     fuse_opt_parse(&args, &mo, fm_mount_opts, NULL);
 
+    if (mo.logfile)
+    {
+        FILE *newlog;
+        fclose(stderr);
+        newlog = fopen(mo.logfile, "wb");
+        if (!newlog)
+        {
+            printf("Can't open specified logfile %s for writing, error %d\n",
+                    mo.logfile, errno);
+            return errno;
+        }
+        logfile = newlog;
+    }
+
     /* Validate options */
     if (!mo.basedir)
     {
-        fprintf(stderr, "Need to specify a basedir\n");
+        fprintf(logfile, "Need to specify a basedir\n");
         return EINVAL;
     }
-    fprintf(stderr, "mo.basedir %s\n", mo.basedir);
+    fprintf(logfile, "mo.basedir %s\n", mo.basedir);
 
     if (!mo.cachedir)
     {
-        fprintf(stderr, "Need to specify a cachedir\n");
+        fprintf(logfile, "Need to specify a cachedir\n");
         return EINVAL;
     }
 
     if (mo.cachesize < CACHE_MIN_SIZE)
     {
-        fprintf(stderr, "Cache size %lld is too small; minimum allowed is %lld\n",
+        fprintf(logfile, "Cache size %lld is too small; minimum allowed is %lld\n",
                 mo.cachesize, CACHE_MIN_SIZE);
         return EINVAL;
     }
 
     if (!mo.db_file)
     {
-        fprintf(stderr, "Need to specify a db_file\n");
+        fprintf(logfile, "Need to specify a db_file\n");
         return EINVAL;
     }
 
@@ -535,7 +554,7 @@ int main(int argc, char *argv[])
             }
             if (i == OUTFMT_INVALID)
             {
-                fprintf(stderr, "%s not recognised as a valid output format\n", mo.format);
+                fprintf(logfile, "%s not recognised as a valid output format\n", mo.format);
                 return EINVAL;
             }
         }
@@ -547,26 +566,26 @@ int main(int argc, char *argv[])
     db_state = db_open(mo.db_file);
     if (!db_state)
     {
-        fprintf(stderr, "Failed to open database %s\n", mo.db_file);
+        fprintf(logfile, "Failed to open database %s\n", mo.db_file);
         return 1;
     }
 
     error = cache_init(db_state, mo.cachedir, mo.cachesize);
     if (error)
     {
-        fprintf(stderr, "Failed to init cache %s, error %d\n", mo.cachedir, error);
+        fprintf(logfile, "Failed to init cache %s, error %d\n", mo.cachedir, error);
         db_close(db_state);
         return 1;
     }
 
     error = fuse_main(args.argc, args.argv, &fm_oper, NULL);
     if (error)
-        fprintf(stderr, "fuse_main failed, error %d\n", error);
+        fprintf(logfile, "fuse_main failed, error %d\n", error);
 
     error = cache_shutdown();
     if (error)
     {
-        fprintf(stderr, "Failed to shutdown cache %s, error %d\n", mo.cachedir, error);
+        fprintf(logfile, "Failed to shutdown cache %s, error %d\n", mo.cachedir, error);
         db_close(db_state);
     }
 
index b6aae3a..918aed8 100644 (file)
--- a/C/misc.c
+++ b/C/misc.c
@@ -1,6 +1,7 @@
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <stdio.h>
 #include "misc.h"
 
 char *strip_leading_path(const char *path, const char *lead)
index abd0021..b4443ca 100644 (file)
--- a/C/misc.h
+++ b/C/misc.h
@@ -1,6 +1,8 @@
 #ifndef MISC_H
 #define MISC_H
 
+extern FILE *logfile;
+
 char *strip_leading_path(const char *path, const char *lead);
 time_t file_mtime(const char *path);
 ssize_t file_size(const char *path);