modules/filesys/dbcompat.c File Reference

Go to the source code of this file.

Functions

static int convert_old_files (char *path, char *newfiledb)

static void convert_version1 (FILE *fdb_s, FILE *fdb_t)

static void convert_version2 (FILE *fdb_s, FILE *fdb_t)

static int convert_old_db (FILE **fdb_s, char *filedb)

Function Documentation

static int convert_old_db	(	FILE **	fdb_s,
		char *	filedb
	)			`[static]`

Definition at line 231 of file dbcompat.c.

References convert_version1(), convert_version2(), filedb_initdb(), filedb_readtop(), FILEDB_VERSION1, FILEDB_VERSION3, lockfile(), LOG_MISC, movefile(), putlog(), unlockfile(), and filedb_top::version.

Referenced by filedb_open().

00232 {
00233   filedb_top fdbt;
00234   FILE *fdb_t;
00235   int ret = 0;          /* Default to 'failure' */
00236 
00237   filedb_readtop(*fdb_s, &fdbt);
00238   /* Old DB version? */
00239   if (fdbt.version > 0 && fdbt.version < FILEDB_VERSION3) {
00240     char *tempdb;
00241 
00242     putlog(LOG_MISC, "*", "Converting old filedb %s to newest format.",
00243      filedb);
00244     /* Create temp DB name */
00245     tempdb = malloc(strlen(filedb) + 5);
00246     simple_sprintf(tempdb, "%s-tmp", filedb);
00247 
00248     fdb_t = fopen(tempdb, "w+b");   /* Open temp DB   */
00249     if (fdb_t) {
00250       filedb_initdb(fdb_t);     /* Initialise new DB  */
00251 
00252       /* Convert old database to new one, saving
00253        * in temporary db file
00254        */
00255       if (fdbt.version == FILEDB_VERSION1)
00256         convert_version1(*fdb_s, fdb_t);  /* v1 -> v3   */
00257       else
00258   convert_version2(*fdb_s, fdb_t);  /* v2 -> v3   */
00259 
00260       unlockfile(*fdb_s);
00261       fclose(fdb_t);
00262       fclose(*fdb_s);
00263 
00264       /* Move over db to new location */
00265       if (movefile(tempdb, filedb))
00266   putlog(LOG_MISC, "*", "(!) Moving file db from %s to %s failed.",
00267       tempdb, filedb);
00268 
00269       *fdb_s = fopen(filedb, "r+b");    /* Reopen new db  */
00270       if (*fdb_s) {
00271   lockfile(*fdb_s);
00272   /* Now we should have recreated the original situation,
00273    * with the file pointer just pointing to the new version
00274    * of the DB instead of the original one.
00275    */
00276   ret = 1;
00277       } else
00278         putlog(LOG_MISC, "*", "(!) Reopening db %s failed.", filedb);
00279     }
00280     free_null(tempdb);
00281   /* Database already at the newest version? */
00282   } else if (fdbt.version == FILEDB_VERSION3) {
00283     ret = 1;          /* Always successfull */
00284   /* Unknown version? */
00285   } else {
00286     putlog(LOG_MISC, "*", "(!) Unknown db version: %d", fdbt.version);
00287   }
00288   if (!ret)
00289     putlog(LOG_MISC, "*", "Conversion of filedb %s failed.", filedb);
00290   return ret;
00291 }

static int convert_old_files	(	char *	path,
		char *	newfiledb
	)			`[static]`

Definition at line 44 of file dbcompat.c.

References _, filedb_entry::desc, FILE_DIR, filedb_addfile, filedb_initdb(), filedb_entry::filename, filedb_entry::flags_req, free_fdbe(), filedb_entry::gots, lockfile(), LOG_FILES, LOG_MISC, malloc_fdbe, NULL, putlog(), filedb_entry::size, filedb_entry::stat, unlockfile(), filedb_entry::uploaded, and filedb_entry::uploader.

Referenced by filedb_open().

00045 {
00046   FILE *f, *fdb;
00047   char *s, *fn, *nick, *tm, *s1;
00048   filedb_entry *fdbe = NULL;
00049   int in_file = 0, i;
00050   struct stat st;
00051 
00052   s = malloc(strlen(path) + 8);
00053   sprintf(s, "%s/.files", path);
00054   f = fopen(s, "r");
00055   free_null(s);
00056   if (f == NULL)
00057     return 0;
00058 
00059   fdb = fopen(newfiledb, "w+b");
00060   if (!fdb) {
00061     putlog(LOG_MISC, "(!) Can't create filedb in %s", newfiledb);
00062     fclose(f);
00063     return 0;
00064   }
00065   lockfile(fdb);
00066   lockfile(f);
00067   filedb_initdb(fdb);
00068 
00069   putlog(LOG_FILES, "*", _("Converting filesystem image in %s ..."), path);
00070   /* Scan contents of .files and painstakingly create .filedb entries */
00071   while (!feof(f)) {
00072     s = malloc(121);
00073     s1 = s;
00074     fgets(s, 120, f);
00075     if (s[strlen(s) - 1] == '\n')
00076       s[strlen(s) - 1] = 0;
00077     if (!feof(f)) {
00078       fn = newsplit(&s1);
00079       rmspace(fn);
00080       if ((fn[0]) && (fn[0] != ';') && (fn[0] != '#')) {
00081   /* Not comment */
00082   if (fn[0] == '-') {
00083     /* Adjust comment for current file */
00084     if (in_file && fdbe) {
00085       rmspace(s);
00086       if (fdbe->desc) {
00087         fdbe->desc = realloc(fdbe->desc,
00088             strlen(fdbe->desc) + strlen(s) + 2);
00089         strcat(fdbe->desc, "\n");
00090       } else
00091         fdbe->desc = malloc(strlen(s) + 2);
00092       strcat(fdbe->desc, s);
00093     }
00094   } else {
00095     if (fdbe) {
00096       /* File pending. Write to DB */
00097       filedb_addfile(fdb, fdbe);
00098       free_fdbe(&fdbe);
00099     }
00100     fdbe = malloc_fdbe();
00101     in_file = 1;
00102     nick = newsplit(&s1);
00103     rmspace(nick);
00104     tm = newsplit(&s1);
00105     rmspace(tm);
00106     rmspace(s1);
00107     i = strlen(fn) - 1;
00108     if (fn[i] == '/')
00109       fn[i] = 0;
00110     realloc_strcpy(fdbe->filename, fn);
00111     realloc_strcpy(fdbe->uploader, nick);
00112     fdbe->gots = atoi(s1);
00113     fdbe->uploaded = atoi(tm);
00114     sprintf(s, "%s/%s", path, fn);
00115     if (stat(s, &st) == 0) {
00116       /* File is okay */
00117       if (S_ISDIR(st.st_mode)) {
00118         fdbe->stat |= FILE_DIR;
00119         if (nick[0] == '+') {
00120     char x[100];
00121     /* Only do global flags, it's an old one */
00122     struct flag_record fr = {FR_GLOBAL, 0, 0, 0, 0, 0};
00123 
00124     break_down_flags(nick + 1, &fr, NULL);
00125     build_flags(x, &fr, NULL);
00126     /* We only want valid flags */
00127     realloc_strcpy(fdbe->flags_req, x);
00128         }
00129       }
00130       fdbe->size = st.st_size;
00131     } else
00132       in_file = 0;  /* skip */
00133   }
00134       }
00135     }
00136     free_null(s);
00137   }
00138   if (fdbe) {
00139     /* File pending. Write to DB */
00140     filedb_addfile(fdb, fdbe);
00141     free_fdbe(&fdbe);
00142   }
00143   fseek(fdb, 0L, SEEK_END);
00144   unlockfile(f);
00145   unlockfile(fdb);
00146   fclose(fdb);
00147   fclose(f);
00148   return 1;
00149 }

static void convert_version1	(	FILE *	fdb_s,
		FILE *	fdb_t
	)			`[static]`

Definition at line 154 of file dbcompat.c.

References filedb_entry::desc, filedb1::desc, FILE_UNUSED, filedb_addfile, filedb_entry::filename, filedb1::filename, filedb_entry::flags_req, filedb1::flags_req, free_fdbe(), filedb1::gots, filedb_entry::gots, malloc_fdbe, filedb1::size, filedb_entry::size, filedb_entry::stat, filedb1::stat, filedb1::uploaded, filedb_entry::uploaded, filedb_entry::uploader, and filedb1::uploader.

Referenced by convert_old_db().

00155 {
00156   filedb1 fdb1;
00157 
00158   fseek(fdb_s, 0L, SEEK_SET);
00159   while (!feof(fdb_s)) {
00160     fread(&fdb1, sizeof(filedb1), 1, fdb_s);
00161     if (!feof(fdb_s)) {
00162       if (!(fdb1.stat & FILE_UNUSED)) {
00163   filedb_entry *fdbe = malloc_fdbe();
00164 
00165   fdbe->stat = fdb1.stat;
00166   if (fdb1.filename[0])
00167     realloc_strcpy(fdbe->filename, fdb1.filename);
00168   if (fdb1.desc[0])
00169     realloc_strcpy(fdbe->desc, fdb1.desc);
00170   if (fdb1.uploader[0])
00171     realloc_strcpy(fdbe->uploader, fdb1.uploader);
00172   if (fdb1.flags_req[0])
00173     realloc_strcpy(fdbe->flags_req, fdb1.flags_req);
00174   fdbe->uploaded = fdb1.uploaded;
00175   fdbe->size = fdb1.size;
00176   fdbe->gots = fdb1.gots;
00177   filedb_addfile(fdb_s, fdbe);
00178   free_fdbe(&fdbe);
00179       }
00180     }
00181   }
00182 }

static void convert_version2	(	FILE *	fdb_s,
		FILE *	fdb_t
	)			`[static]`

Definition at line 187 of file dbcompat.c.

References filedb_entry::chan, filedb2::chname, filedb_entry::desc, filedb2::desc, FILE_UNUSED, filedb_addfile, filedb_entry::filename, filedb2::filename, filedb_entry::flags_req, filedb2::flags_req, free_fdbe(), filedb2::gots, filedb_entry::gots, malloc_fdbe, filedb2::size, filedb_entry::size, filedb_entry::stat, filedb2::stat, filedb2::uploaded, filedb_entry::uploaded, filedb_entry::uploader, and filedb2::uploader.

Referenced by convert_old_db().

00188 {
00189   filedb2 fdb2;
00190 
00191   fseek(fdb_s, 0L, SEEK_SET);
00192   while (!feof(fdb_s)) {
00193     fread(&fdb2, sizeof(filedb2), 1, fdb_s);
00194     if (!feof(fdb_s)) {
00195       if (!(fdb2.stat & FILE_UNUSED)) {
00196   filedb_entry *fdbe = malloc_fdbe();
00197 
00198   fdbe->stat = fdb2.stat;
00199   if (fdb2.filename[0])
00200     realloc_strcpy(fdbe->filename, fdb2.filename);
00201   if (fdb2.desc[0])
00202     realloc_strcpy(fdbe->desc, fdb2.desc);
00203   if (fdb2.chname[0])
00204     realloc_strcpy(fdbe->chan, fdb2.chname);
00205   if (fdb2.uploader[0])
00206     realloc_strcpy(fdbe->uploader, fdb2.uploader);
00207   if (fdb2.flags_req[0])
00208     realloc_strcpy(fdbe->flags_req, fdb2.flags_req);
00209   fdbe->uploaded = fdb2.uploaded;
00210   fdbe->size = fdb2.size;
00211   fdbe->gots = fdb2.gots;
00212   filedb_addfile(fdb_t, fdbe);
00213   free_fdbe(&fdbe);
00214       }
00215     }
00216   }
00217 }


Functions
static int	convert_old_files (char path, char newfiledb)
static void	convert_version1 (FILE fdb_s, FILE fdb_t)
static void	convert_version2 (FILE fdb_s, FILE fdb_t)
static int	convert_old_db (FILE *fdb_s, char filedb)