modules/filesys/filedb3.c File Reference

Go to the source code of this file.

Defines
#define	filedb_read(fdb, entry, len)
Functions
static int	wild_match_file (register char *m, register char *n)
static void	free_fdbe (filedb_entry **fdbe)
static filedb_entry *	_malloc_fdbe (char *file, int line)
static void	lockfile (FILE *fdb)
static void	unlockfile (FILE *f)
static int	filedb_readtop (FILE *fdb, filedb_top *fdbt)
static int	filedb_writetop (FILE *fdb, filedb_top *fdbt)
static int	filedb_delfile (FILE *fdb, long pos)
static filedb_entry *	filedb_findempty (FILE *fdb, int tot)
static int	_filedb_updatefile (FILE *fdb, long pos, filedb_entry *fdbe, int update, char *file, int line)
static int	_filedb_movefile (FILE *fdb, long pos, filedb_entry *fdbe, char *file, int line)
static int	_filedb_addfile (FILE *fdb, filedb_entry *fdbe, char *file, int line)
static filedb_entry *	_filedb_getfile (FILE *fdb, long pos, int get, char *file, int line)
static filedb_entry *	_filedb_matchfile (FILE *fdb, long pos, char *match, char *file, int line)
static void	filedb_cleanup (FILE *fdb)
static void	filedb_mergeempty (FILE *fdb)
static filedb_entry *	filedb_getentry (char *dir, char *fn)
static void	filedb_initdb (FILE *fdb)
static void	filedb_timestamp (FILE *fdb)
static void	filedb_update (char *path, FILE *fdb, int sort)
static char *	make_point_path (char *path)
static FILE *	filedb_open (char *path, int sort)
static void	filedb_close (FILE *fdb)
static void	filedb_add (FILE *fdb, char *filename, char *nick)
static void	filedb_ls (FILE *fdb, int idx, char *mask, int showall)
static void	filedb_getdesc (char *dir, char *fn, char **desc)
static void	filedb_getowner (char *dir, char *fn, char **owner)
static int	filedb_getgots (char *dir, char *fn)
static void	filedb_setdesc (char *dir, char *fn, char *desc)
static void	filedb_setowner (char *dir, char *fn, char *owner)
static void	filedb_getfiles (Tcl_Interp *irp, char *dir)
static void	filedb_getdirs (Tcl_Interp *irp, char *dir)
static void	filedb_change (char *dir, char *fn)
Variables
static int	count = 0

---

Define Documentation

#define filedb_read	(	fdb,
		entry,
		len		)

Value:

{         \
  if ((len) > 0) {      \
    (entry) = malloc((len));    \
    fread((entry), 1, (len), (fdb));  \
  }         \
}

Definition at line 461 of file filedb3.c.

Referenced by _filedb_getfile().

---

Function Documentation

static int _filedb_addfile	(	FILE *	fdb,
		filedb_entry *	fdbe,
		char *	file,
		int	line
	)			[static]

Definition at line 451 of file filedb3.c.

References _filedb_updatefile(), filedb_entry::_type, POS_NEW, TYPE_NEW, and UPDATE_ALL.

{
  fdbe->_type = TYPE_NEW;
  _filedb_updatefile(fdb, POS_NEW, fdbe, UPDATE_ALL, file, line);
  return 0;
}

static filedb_entry* _filedb_getfile	(	FILE *	fdb,
		long	pos,
		int	get,
		char *	file,
		int	line
	)			[static]

Definition at line 474 of file filedb3.c.

References _malloc_fdbe(), filedb_entry::_type, filedb_entry::buf_len, filedb_header::buffer_len, filedb_entry::chan, filedb_header::chan_len, filedb_entry::desc, filedb_header::desc_len, filedb_entry::dyn_len, FILE_UNUSED, filedb_read, filedb_tot_dynspace, filedb_entry::filename, filedb_header::filename_len, filedb_entry::flags_req, filedb_header::flags_req_len, GET_FILENAME, GET_FULL, filedb_header::gots, filedb_entry::gots, NULL, filedb_entry::pos, filedb_header::size, filedb_entry::size, filedb_header::stat, filedb_entry::stat, TYPE_EXIST, filedb_header::uploaded, filedb_entry::uploaded, filedb_entry::uploader, and filedb_header::uploader_len.

Referenced by _filedb_matchfile().

{
  filedb_entry *fdbe;
  filedb_header fdh;

  /* Read header */
  fseek(fdb, pos, SEEK_SET);
  fread(&fdh, 1, sizeof(filedb_header), fdb);
  if (feof(fdb))
    return NULL;

  /* Allocate memory for file db entry */
  fdbe = _malloc_fdbe(file, line);

  /* Optimisation: maybe use memcpy here? */
  fdbe->uploaded = fdh.uploaded;
  fdbe->size = fdh.size;
  fdbe->stat = fdh.stat;
  fdbe->gots = fdh.gots;

  fdbe->buf_len = fdh.buffer_len;
  fdbe->dyn_len = filedb_tot_dynspace(fdh);
  fdbe->pos = pos;      /* Save position    */
  fdbe->_type = TYPE_EXIST;   /* Entry exists in DB   */

  /* Read additional data from db */
  if (get >= GET_FILENAME) {
    filedb_read(fdb, fdbe->filename, fdh.filename_len);
  } else
    fseek(fdb, fdh.filename_len, SEEK_CUR);
  if (get < GET_FULL || (fdh.stat & FILE_UNUSED))
    fseek(fdb, filedb_tot_dynspace(fdh) - fdh.filename_len, SEEK_CUR);
  else if (get == GET_FULL) {
    filedb_read(fdb, fdbe->desc, fdh.desc_len);
    filedb_read(fdb, fdbe->chan, fdh.chan_len);
    filedb_read(fdb, fdbe->uploader, fdh.uploader_len);
    filedb_read(fdb, fdbe->flags_req, fdh.flags_req_len);
  }
  fseek(fdb, fdh.buffer_len, SEEK_CUR); /* Skip buffer      */
  return fdbe;        /* Return the ready structure */
}

static filedb_entry* _filedb_matchfile	(	FILE *	fdb,
		long	pos,
		char *	match,
		char *	file,
		int	line
	)			[static]

Definition at line 520 of file filedb3.c.

References _filedb_getfile(), FILE_UNUSED, filedb_getfile, filedb_entry::filename, free_fdbe(), GET_FILENAME, GET_FULL, NULL, filedb_entry::stat, and wild_match_file().

{
  filedb_entry *fdbe = NULL;

  fseek(fdb, pos, SEEK_SET);
  while (!feof(fdb))
  {
    pos = ftell(fdb);
    fdbe = filedb_getfile(fdb, pos, GET_FILENAME);
    if (fdbe) {
      if (!(fdbe->stat & FILE_UNUSED) &&      /* Not unused?     */
    wild_match_file(match, fdbe->filename)) { /* Matches our mask?   */
        free_fdbe(&fdbe);
        fdbe = _filedb_getfile(fdb, pos, GET_FULL,
             file, line);     /* Save all data now   */
        return fdbe;
      }
      free_fdbe(&fdbe);
    }
  }
  return NULL;
}

static int _filedb_movefile	(	FILE *	fdb,
		long	pos,
		filedb_entry *	fdbe,
		char *	file,
		int	line
	)			[static]

Definition at line 441 of file filedb3.c.

References _filedb_updatefile(), filedb_entry::_type, TYPE_EXIST, and UPDATE_ALL.

{
  fdbe->_type = TYPE_EXIST;
  _filedb_updatefile(fdb, pos, fdbe, UPDATE_ALL, file, line);
  return 0;
}

static int _filedb_updatefile	(	FILE *	fdb,
		long	pos,
		filedb_entry *	fdbe,
		int	update,
		char *	file,
		int	line
	)			[static]

Definition at line 325 of file filedb3.c.

References filedb_entry::_type, filedb_entry::buf_len, filedb_header::buffer_len, filedb_entry::chan, filedb_header::chan_len, filedb_entry::desc, filedb_header::desc_len, filedb_entry::dyn_len, filedb_delfile(), filedb_findempty(), filedb_tot_dynspace, filedb_entry::filename, filedb_header::filename_len, filedb_entry::flags_req, filedb_header::flags_req_len, free_fdbe(), filedb_entry::gots, filedb_header::gots, filedb_entry::pos, POS_NEW, filedb_entry::size, filedb_header::size, filedb_entry::stat, filedb_header::stat, TYPE_EXIST, UPDATE_ALL, UPDATE_SIZE, filedb_entry::uploaded, filedb_header::uploaded, filedb_entry::uploader, and filedb_header::uploader_len.

Referenced by _filedb_addfile(), and _filedb_movefile().

{
  filedb_header fdh;
  int reposition = 0;
  int ndyntot, odyntot, nbuftot, obuftot;

  memset(&fdh, 0, sizeof(filedb_header));
  fdh.uploaded = fdbe->uploaded;
  fdh.size = fdbe->size;
  fdh.stat = fdbe->stat;
  fdh.gots = fdbe->gots;

  /* Only add the buffer length if the buffer is not empty. Otherwise it
   * would result in lots of 1 byte entries which actually don't contain
   * any data.
   */
  if (fdbe->filename)
    fdh.filename_len = strlen(fdbe->filename) + 1;
  if (fdbe->desc)
    fdh.desc_len = strlen(fdbe->desc) + 1;
  if (fdbe->chan)
    fdh.chan_len = strlen(fdbe->chan) + 1;
  if (fdbe->uploader)
    fdh.uploader_len = strlen(fdbe->uploader) + 1;
  if (fdbe->flags_req)
    fdh.flags_req_len = strlen(fdbe->flags_req) + 1;

  odyntot = fdbe->dyn_len;    /* Old length of dynamic data */
  obuftot = fdbe->buf_len;    /* Old length of spare space  */
  ndyntot = filedb_tot_dynspace(fdh); /* New length of dynamic data */
  nbuftot = obuftot;

  if (fdbe->_type == TYPE_EXIST) {
    /* If we only update the header, we don't need to worry about
     * sizes and just use the old place (i.e. the place pointed
     * to by pos).
     */
    if (update < UPDATE_ALL) {
      /* Unless forced to it, we ignore new buffer sizes if we do not
       * run in UPDATE_ALL mode.
       */
      if (update != UPDATE_SIZE) {
        ndyntot = odyntot;
        nbuftot = obuftot;
      }
    } else {
      /* If we have a given/preferred position */
      if ((pos != POS_NEW) &&
   /* and if our new size is smaller than the old size, we
    * just adjust the buffer length and still use the same
    * position
    */
          (ndyntot <= (odyntot + obuftot))) {
  nbuftot = (odyntot + obuftot) - ndyntot;
      } else {
  /* If we have an existing position, but the new entry doesn't
   * fit into it's old home, we need to delete it before
   * repositioning.
   */
  if (pos != POS_NEW)
          filedb_delfile(fdb, pos);
  reposition = 1;
      }
    }
  } else {
    fdbe->_type = TYPE_EXIST;   /* Update type      */
    reposition = 1;
  }

  /* Search for a new home */
  if (reposition) {
    filedb_entry *n_fdbe;

    n_fdbe = filedb_findempty(fdb, filedb_tot_dynspace(fdh));
    fdbe->pos = pos = n_fdbe->pos;
    /* If we create a new entry (instead of using an existing one),
     * buf_len is zero
     */
    if (n_fdbe->buf_len > 0)
      /* Note: empty entries have dyn_len set to zero, so we only
       *       need to consider buf_len.
       */
      nbuftot = n_fdbe->buf_len - ndyntot;
    else
      nbuftot = 0;
    free_fdbe(&n_fdbe);
  }

  /* Set length of dynamic data and buffer */
  fdbe->dyn_len = ndyntot;
  fdbe->buf_len = fdh.buffer_len = nbuftot;

  /* Write header */
  fseek(fdb, pos, SEEK_SET);
  fwrite(&fdh, 1, sizeof(filedb_header), fdb);
  /* Write dynamic data */
  if (update == UPDATE_ALL) {
    if (fdbe->filename)
      fwrite(fdbe->filename, 1, fdh.filename_len, fdb);
    if (fdbe->desc)
      fwrite(fdbe->desc, 1, fdh.desc_len, fdb);
    if (fdbe->chan)
      fwrite(fdbe->chan, 1, fdh.chan_len, fdb);
    if (fdbe->uploader)
      fwrite(fdbe->uploader, 1, fdh.uploader_len, fdb);
    if (fdbe->flags_req)
      fwrite(fdbe->flags_req, 1, fdh.flags_req_len, fdb);
  } else
    fseek(fdb, ndyntot, SEEK_CUR);  /* Skip over dynamic data */
  fseek(fdb, nbuftot, SEEK_CUR);  /* Skip over buffer   */
  return 0;
}

static filedb_entry* _malloc_fdbe	(	char *	file,
		int	line
	)			[static]

Definition at line 159 of file filedb3.c.

References filedb_entry::_type, NULL, and TYPE_NEW.

Referenced by _filedb_getfile().

{
  filedb_entry *fdbe = NULL;

  fdbe = calloc(1, sizeof(filedb_entry));

  /* Mark as new, will be overwritten if necessary. */
  fdbe->_type = TYPE_NEW;
  return fdbe;
}

static void filedb_add	(	FILE *	fdb,
		char *	filename,
		char *	nick
	)			[static]

Definition at line 891 of file filedb3.c.

References filedb_matchfile, filedb_readtop(), filedb_updatefile, free_fdbe(), now, NULL, filedb_entry::pos, UPDATE_ALL, filedb_entry::uploaded, and filedb_entry::uploader.

Referenced by add_file().

{
  filedb_entry *fdbe = NULL;

  filedb_readtop(fdb, NULL);
  /* When the filedb was opened, a record was already created. */
  fdbe = filedb_matchfile(fdb, ftell(fdb), filename);
  if (!fdbe)
    return;
  free_null(fdbe->uploader);
  realloc_strcpy(fdbe->uploader, nick);
  fdbe->uploaded = now;
  filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_ALL);
  free_fdbe(&fdbe);
}

static void filedb_change	(	char *	dir,
		char *	fn
	)			[static]

Definition at line 1173 of file filedb3.c.

References FILE_DIR, filedb_close(), filedb_matchfile, filedb_open(), filedb_readtop(), filedb_updatefile, free_fdbe(), NULL, filedb_entry::pos, filedb_entry::stat, and UPDATE_HEADER.

Referenced by tcl_hide(), and tcl_unhide().

{
  FILE *fdb;
  filedb_entry *fdbe;
  int changed = 0;

  fdb = filedb_open(dir, 0);
  if (!fdb)
    return;
  filedb_readtop(fdb, NULL);
  fdbe = filedb_matchfile(fdb, ftell(fdb), fn);
  if (fdbe) {
    if (!(fdbe->stat & FILE_DIR))
      changed = 1;
    if (changed)
      filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_HEADER);
    free_fdbe(&fdbe);
  }
  filedb_close(fdb);
}

static void filedb_cleanup

(

FILE *

fdb

)

[static]

Definition at line 547 of file filedb3.c.

References FILE_UNUSED, filedb_getfile, filedb_movefile, filedb_readtop(), free_fdbe(), GET_FULL, GET_HEADER, NULL, and filedb_entry::stat.

Referenced by filedb_update().

{
  long oldpos, newpos, temppos;
  filedb_entry *fdbe = NULL;

  filedb_readtop(fdb, NULL);        /* Skip DB header  */
  newpos = temppos = oldpos = ftell(fdb);
  fseek(fdb, oldpos, SEEK_SET);       /* Go to beginning */
  while (!feof(fdb))          /* Loop until EOF  */
  {
    fdbe = filedb_getfile(fdb, oldpos, GET_HEADER); /* Read header     */
    if (fdbe) {
      if (fdbe->stat & FILE_UNUSED) {     /* Found dirt!     */
        free_fdbe(&fdbe);
  while (!feof(fdb)) {        /* Loop until EOF  */
    newpos = ftell(fdb);
    fdbe = filedb_getfile(fdb, newpos, GET_FULL); /* Read next entry */
    if (!fdbe)
      break;
    if (!(fdbe->stat & FILE_UNUSED)) {    /* Not unused?     */
      temppos = ftell(fdb);
      filedb_movefile(fdb, oldpos, fdbe);   /* Move to top     */
      oldpos = ftell(fdb);
      fseek(fdb, temppos, SEEK_SET);
    }
    free_fdbe(&fdbe);
  }
      } else {
        free_fdbe(&fdbe);
  oldpos = ftell(fdb);
      }
    }
  }
  ftruncate(fileno(fdb), oldpos);     /* Shorten file    */
}

static void filedb_close

(

FILE *

fdb

)

[static]

Definition at line 878 of file filedb3.c.

References count, filedb_timestamp(), and unlockfile().

Referenced by add_file(), cmd_desc(), cmd_hide(), cmd_mkdir(), cmd_mv_cp(), cmd_optimize(), cmd_reget_get(), cmd_rm(), cmd_rmdir(), cmd_unhide(), filedb_change(), filedb_getdirs(), filedb_getentry(), filedb_getfiles(), filedb_setdesc(), filedb_setowner(), files_ls(), files_reget(), incr_file_gots(), resolve_dir(), tcl_mkdir(), tcl_mv_cp(), tcl_rmdir(), tcl_setflags(), and welcome_to_files().

{
  filedb_timestamp(fdb);
  fseek(fdb, 0L, SEEK_END);
  count--;
  unlockfile(fdb);
  fclose(fdb);
}

static int filedb_delfile	(	FILE *	fdb,
		long	pos
	)			[static]

Definition at line 236 of file filedb3.c.

References filedb_header::buffer_len, FILE_UNUSED, filedb_tot_dynspace, filedb_zero_dynspace, and filedb_header::stat.

Referenced by _filedb_updatefile(), cmd_mv_cp(), cmd_rm(), cmd_rmdir(), filedb_update(), tcl_mv_cp(), and tcl_rmdir().

{
  filedb_header fdh;

  fseek(fdb, pos, SEEK_SET);      /* Go to start of entry */
  if (feof(fdb))
    return 0;
  fread(&fdh, 1, sizeof(filedb_header), fdb); /* Read header    */
  fdh.stat = FILE_UNUSED;

  /* Assign all available space to buffer. Simplifies
   * space calculation later on.
   */
  fdh.buffer_len += filedb_tot_dynspace(fdh);
  filedb_zero_dynspace(fdh);

  fseek(fdb, pos, SEEK_SET);      /* Go back to start */
  fwrite(&fdh, 1, sizeof(filedb_header), fdb);  /* Write new header */
  return 1;
}

static filedb_entry* filedb_findempty	(	FILE *	fdb,
		int	tot
	)			[static]

Definition at line 269 of file filedb3.c.

References filedb_entry::buf_len, FILE_UNUSED, FILEDB_ESTDYN, filedb_getfile, filedb_movefile, filedb_readtop(), free_fdbe(), GET_HEADER, malloc_fdbe, NULL, filedb_entry::pos, and filedb_entry::stat.

Referenced by _filedb_updatefile().

{
  filedb_entry *fdbe;

  filedb_readtop(fdb, NULL);
  fdbe = filedb_getfile(fdb, ftell(fdb), GET_HEADER);
  while (fdbe) {
    /* Found an existing, empty entry? */
    if ((fdbe->stat & FILE_UNUSED) && (fdbe->buf_len >= tot)) {
      /* Do we have enough space to split up the entry to form
       * another empty entry? That way we would use the space
       * more efficiently.
       */
      if (fdbe->buf_len > (tot + sizeof(filedb_header) + FILEDB_ESTDYN)) {
  filedb_entry *fdbe_oe;

  /* Create new entry containing the additional space */
  fdbe_oe = malloc_fdbe();
  fdbe_oe->stat = FILE_UNUSED;
  fdbe_oe->pos = fdbe->pos + sizeof(filedb_header) + tot;
  fdbe_oe->buf_len = fdbe->buf_len - tot - sizeof(filedb_header);
  filedb_movefile(fdb, fdbe_oe->pos, fdbe_oe);
  free_fdbe(&fdbe_oe);

  /* Cut down buf_len of entry as the rest is now used in the new
   * entry.
   */
  fdbe->buf_len = tot;
      }
      return fdbe;
    }
    free_fdbe(&fdbe);
    fdbe = filedb_getfile(fdb, ftell(fdb), GET_HEADER);
  }

  /* No existing entries, so create new entry at end of DB instead. */
  fdbe = malloc_fdbe();
  fseek(fdb, 0L, SEEK_END);
  fdbe->pos = ftell(fdb);
  return fdbe;
}

static void filedb_getdesc	(	char *	dir,
		char *	fn,
		char **	desc
	)			[static]

Definition at line 1058 of file filedb3.c.

References filedb_entry::desc, filedb_getentry(), free_fdbe(), and NULL.

Referenced by tcl_getdesc().

{
  filedb_entry *fdbe = NULL;

  fdbe = filedb_getentry(dir, fn);
  if (fdbe) {
    *desc = strdup(fdbe->desc);
    free_fdbe(&fdbe);
  } else
    *desc = NULL;
}

static void filedb_getdirs	(	Tcl_Interp *	irp,
		char *	dir
	)			[static]

Definition at line 1153 of file filedb3.c.

References FILE_DIR, FILE_UNUSED, filedb_close(), filedb_getfile, filedb_open(), filedb_readtop(), filedb_entry::filename, free_fdbe(), GET_FILENAME, NULL, and filedb_entry::stat.

Referenced by tcl_getdirs().

{
  FILE *fdb;
  filedb_entry *fdbe;

  fdb = filedb_open(dir, 0);
  if (!fdb)
    return;
  filedb_readtop(fdb, NULL);
  while (!feof(fdb)) {
    fdbe = filedb_getfile(fdb, ftell(fdb), GET_FILENAME);
    if (fdbe) {
      if ((!(fdbe->stat & FILE_UNUSED)) && (fdbe->stat & FILE_DIR))
  Tcl_AppendElement(irp, fdbe->filename);
      free_fdbe(&fdbe);
    }
  }
  filedb_close(fdb);
}

static filedb_entry* filedb_getentry	(	char *	dir,
		char *	fn
	)			[static]

Definition at line 638 of file filedb3.c.

References filedb_close(), filedb_matchfile, filedb_open(), filedb_readtop(), and NULL.

Referenced by filedb_getdesc(), filedb_getgots(), filedb_getowner(), and tcl_getflags().

{
  FILE *fdb;
  filedb_entry *fdbe = NULL;

  fdb = filedb_open(dir, 0);
  if (fdb) {
    filedb_readtop(fdb, NULL);
    fdbe = filedb_matchfile(fdb, ftell(fdb), fn);
    filedb_close(fdb);
  }
  return fdbe;
}

static void filedb_getfiles	(	Tcl_Interp *	irp,
		char *	dir
	)			[static]

Definition at line 1133 of file filedb3.c.

References FILE_DIR, FILE_UNUSED, filedb_close(), filedb_getfile, filedb_open(), filedb_readtop(), filedb_entry::filename, free_fdbe(), GET_FILENAME, NULL, and filedb_entry::stat.

Referenced by tcl_getfiles().

{
  FILE *fdb;
  filedb_entry *fdbe;

  fdb = filedb_open(dir, 0);
  if (!fdb)
    return;
  filedb_readtop(fdb, NULL);
  while (!feof(fdb)) {
    fdbe = filedb_getfile(fdb, ftell(fdb), GET_FILENAME);
    if (fdbe) {
      if (!(fdbe->stat & (FILE_DIR | FILE_UNUSED)))
  Tcl_AppendElement(irp, fdbe->filename);
      free_fdbe(&fdbe);
    }
  }
  filedb_close(fdb);
}

static int filedb_getgots	(	char *	dir,
		char *	fn
	)			[static]

Definition at line 1082 of file filedb3.c.

References filedb_getentry(), free_fdbe(), filedb_entry::gots, and NULL.

Referenced by tcl_getgots().

{
  filedb_entry *fdbe = NULL;
  int         gots = 0;

  fdbe = filedb_getentry(dir, fn);
  if (fdbe) {
    gots = fdbe->gots;
    free_fdbe(&fdbe);
  }
  return gots;
}

static void filedb_getowner	(	char *	dir,
		char *	fn,
		char **	owner
	)			[static]

Definition at line 1070 of file filedb3.c.

References filedb_getentry(), free_fdbe(), NULL, and filedb_entry::uploader.

Referenced by tcl_getowner().

{
  filedb_entry *fdbe = NULL;

  fdbe = filedb_getentry(dir, fn);
  if (fdbe) {
    *owner = strdup(fdbe->uploader);
    free_fdbe(&fdbe);
  } else
    *owner = NULL;
}

static void filedb_initdb

(

FILE *

fdb

)

[static]

Definition at line 654 of file filedb3.c.

References FILEDB_NEWEST_VER, filedb_writetop(), now, filedb_top::timestamp, and filedb_top::version.

Referenced by convert_old_db(), and convert_old_files().

{
  filedb_top fdbt;

  fdbt.version = FILEDB_NEWEST_VER;
  fdbt.timestamp = now;
  filedb_writetop(fdb, &fdbt);
}

static void filedb_ls	(	FILE *	fdb,
		int	idx,
		char *	mask,
		int	showall
	)			[static]

Definition at line 910 of file filedb3.c.

References _, filedb_entry::chan, filedb_entry::desc, FILE_DIR, FILE_HIDDEN, FILE_UNUSED, filedb_getfile, filedb_readtop(), filelist_add(), filelist_addout(), filelist_free(), filelist_idxshow(), filelist_new(), filelist_sort(), filedb_entry::filename, filedb_entry::flags_req, free_fdbe(), GET_FULL, filedb_entry::gots, NULL, P_, filedb_entry::size, filedb_entry::stat, filedb_entry::uploaded, filedb_entry::uploader, and wild_match_file().

Referenced by files_ls().

{
  int  ok = 0, cnt = 0, is = 0;
  char s1[81], *p = NULL;
  struct flag_record user  = {FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0};
  filedb_entry *fdbe  = NULL;
  filelist_t   *flist = NULL;

  flist = filelist_new();
  filedb_readtop(fdb, NULL);
  fdbe = filedb_getfile(fdb, ftell(fdb), GET_FULL);
  while (fdbe) {
    ok = 1;
    if (fdbe->stat & FILE_UNUSED)
      ok = 0;
    if (ok && (fdbe->stat & FILE_DIR) && fdbe->flags_req) {
      /* Check permissions */
      struct flag_record req = {FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0};

      break_down_flags(fdbe->flags_req, &req, NULL);
      get_user_flagrec(dcc[idx].user, &user, dcc[idx].u.file->chat->con_chan);
      if (!flagrec_ok(&req, &user)) {
  ok = 0;
      }
    }
    if (ok)
      is = 1;
    if (ok && !wild_match_file(mask, fdbe->filename))
      ok = 0;
    if (ok && (fdbe->stat & FILE_HIDDEN) && !(showall))
      ok = 0;
    if (ok) {
      /* Display it! */
      if (cnt == 0) {
  dprintf(idx, _("Filename                        Size  Sent by/Date         # Gets\n"));
  dprintf(idx, _("------------------------------  ----  -------------------  ------\n"));
      }
      filelist_add(flist, fdbe->filename);
      if (fdbe->stat & FILE_DIR) {
  char *s2 = NULL, *s3 = NULL;

  /* Too long? */
  if (strlen(fdbe->filename) > 45) {
    /* Display the filename on its own line. */
    s2 = malloc(strlen(fdbe->filename) + 3);
    sprintf(s2, "%s/\n", fdbe->filename);
    filelist_addout(flist, s2);
    free_null(s2);
  } else {
    s2 = malloc(strlen(fdbe->filename) + 2);
    sprintf(s2, "%s/", fdbe->filename);
  }
  /* Note: You have to keep the sprintf and the malloc statements
   *       in sync, i.e. always check that you allocate enough
   *       memory.
   */
  if ((fdbe->flags_req) &&
      (user.global &(USER_MASTER | USER_JANITOR))) {
    s3 = malloc(42 + strlen(s2 ? s2 : "") + 6 +
           strlen(_("requires")) + strlen(fdbe->flags_req) + 1 +
           strlen(fdbe->chan ? fdbe->chan : "") + 1);
    sprintf(s3, "%-30s <DIR>  (%s %s%s%s)\n", s2, _("requires"),
                  fdbe->flags_req, fdbe->chan ? " " : "",
                  fdbe->chan ? fdbe->chan : "");
  } else {
    s3 = malloc(38 + strlen(s2 ? s2 : ""));
    sprintf(s3, "%-30s <DIR>\n", s2 ? s2 : "");
  }
  if (s2)
    free_null(s2);
  filelist_addout(flist, s3);
  free_null(s3);
      } else {
  char s2[41], t[50], *s3 = NULL, *s4;

  s2[0] = 0;
  if (showall) {
    if (fdbe->stat & FILE_HIDDEN)
      strcat(s2, " (hid)");
  }
  strftime(t, 10, "%d%b%Y", localtime(&fdbe->uploaded));
  if (fdbe->size < 1024)
    sprintf(s1, "%5d", fdbe->size);
  else
    sprintf(s1, "%4dk", (int) (fdbe->size / 1024));
  /* Too long? */
  if (strlen(fdbe->filename) > 30) {
    s3 = malloc(strlen(fdbe->filename) + 2);
    sprintf(s3, "%s\n", fdbe->filename);
    filelist_addout(flist, s3);
    free_null(s3);
    /* Causes filename to be displayed on its own line */
  } else
    realloc_strcpy(s3, fdbe->filename);
  s4 = malloc(69 + strlen(s3 ? s3 : "") + strlen(s1) +
         strlen(fdbe->uploader) + strlen(t) + strlen(s2));
  sprintf(s4, "%-30s %s  %-9s (%s)  %6d%s\n", s3 ? s3 : "", s1,
    fdbe->uploader, t, fdbe->gots, s2);
  if (s3)
    free_null(s3);
  filelist_addout(flist, s4);
  free_null(s4);
      }
      if (fdbe->desc) {
  p = strchr(fdbe->desc, '\n');
  while (p != NULL) {
    *p = 0;
    if ((fdbe->desc)[0]) {
      char *sd;

      sd = malloc(strlen(fdbe->desc) + 5);
      sprintf(sd, "   %s\n", fdbe->desc);
      filelist_addout(flist, sd);
      free_null(sd);
    }
    strcpy(fdbe->desc, p + 1);
    p = strchr(fdbe->desc, '\n');
  }
  if ((fdbe->desc)[0]) {
    char *sd;

    sd = malloc(strlen(fdbe->desc) + 5);
    sprintf(sd, "   %s\n", fdbe->desc);
    filelist_addout(flist, sd);
    free_null(sd);
  }
      }
      cnt++;
    }
    free_fdbe(&fdbe);
    fdbe = filedb_getfile(fdb, ftell(fdb), GET_FULL);
  }
  if (is == 0)
    dprintf(idx, _("No files in this directory.\n"));
  else if (cnt == 0)
    dprintf(idx, _("No matching files.\n"));
  else {
    filelist_sort(flist);
    filelist_idxshow(flist, idx);
    dprintf(idx, P_("--- %d file.\n", "--- %d files.\n", cnt), cnt);
  }
  filelist_free(flist);
}

static void filedb_mergeempty

(

FILE *

fdb

)

[static]

Definition at line 588 of file filedb3.c.

References filedb_entry::buf_len, FILE_UNUSED, filedb_getfile, filedb_readtop(), filedb_updatefile, free_fdbe(), GET_HEADER, NULL, filedb_entry::pos, filedb_entry::stat, and UPDATE_SIZE.

Referenced by filedb_open().

{
  filedb_entry *fdbe_t, *fdbe_i;
  int modified;

  filedb_readtop(fdb, NULL);
  while (!feof(fdb))
  {
    fdbe_t = filedb_getfile(fdb, ftell(fdb), GET_HEADER);
    if (fdbe_t) {
      if (fdbe_t->stat & FILE_UNUSED) {
  modified = 0;
  fdbe_i = filedb_getfile(fdb, ftell(fdb), GET_HEADER);
  while (fdbe_i) {
    /* Is this entry in use? */
    if (!(fdbe_i->stat & FILE_UNUSED))
      break;  /* It is, exit loop. */

    /* Woohoo, found an empty entry. Append it's space to
     * our target entry's buffer space.
     */
    fdbe_t->buf_len += sizeof(filedb_header) + fdbe_i->buf_len;
    modified++;
    free_fdbe(&fdbe_i);
    /* Get next file entry */
    fdbe_i = filedb_getfile(fdb, ftell(fdb), GET_HEADER);
  }

  /* Did we exit the loop because of a used entry? */
  if (fdbe_i) {
    free_fdbe(&fdbe_i);
    /* Did we find any empty entries before? */
    if (modified)
      filedb_updatefile(fdb, fdbe_t->pos, fdbe_t, UPDATE_SIZE);
  /* ... or because we hit EOF? */
  } else {
    /* Truncate trailing empty entries and exit. */
    ftruncate(fileno(fdb), fdbe_t->pos);
    free_fdbe(&fdbe_t);
    return;
  }
      }
      free_fdbe(&fdbe_t);
    }
  }
}

static FILE* filedb_open	(	char *	path,
		int	sort
	)			[static]

Definition at line 778 of file filedb3.c.

References _, convert_old_db(), convert_old_files(), count, dccdir, filedb_mergeempty(), FILEDB_NEWEST_VER, filedb_path, filedb_readtop(), filedb_update(), filedb_writetop(), lockfile(), LOG_MISC, make_point_path(), now, NULL, putlog(), filedb_top::timestamp, unlockfile(), and filedb_top::version.

Referenced by add_file(), cmd_desc(), cmd_hide(), cmd_mkdir(), cmd_mv_cp(), cmd_optimize(), cmd_reget_get(), cmd_rm(), cmd_rmdir(), cmd_unhide(), filedb_change(), filedb_getdirs(), filedb_getentry(), filedb_getfiles(), filedb_setdesc(), filedb_setowner(), files_ls(), files_reget(), incr_file_gots(), resolve_dir(), tcl_mkdir(), tcl_mv_cp(), tcl_rmdir(), tcl_setflags(), and welcome_to_files().

{
  char *s, *npath;
  FILE *fdb;
  filedb_top fdbt;
  struct stat st;

  if (count >= 2)
    putlog(LOG_MISC, "*", "(@) warning: %d open filedb's", count);
  npath = malloc(strlen(dccdir) + strlen(path) + 1);
  simple_sprintf(npath, "%s%s", dccdir, path);
  /* Use alternate filename if requested */
  if (filedb_path[0]) {
    char *s2;

    s2 = make_point_path(path);
    s = malloc(strlen(filedb_path) + strlen(s2) + 8);
    simple_sprintf(s, "%sfiledb.%s", filedb_path, s2);
    free_null(s2);
  } else {
    s = malloc(strlen(npath) + 10);
    simple_sprintf(s, "%s/.filedb", npath);
  }
  fdb = fopen(s, "r+b");
  if (!fdb) {
    if (convert_old_files(npath, s)) {
      fdb = fopen(s, "r+b");
      if (fdb == NULL) {
  putlog(LOG_MISC, "*", _("(!) Broken convert to filedb in %s"), npath);
  free_null(s);
  free_null(npath);
        return NULL;
      }
      lockfile(fdb);
      filedb_update(npath, fdb, sort);
      count++;
      free_null(s);
      free_null(npath);
      return fdb;
    } else {
      filedb_top fdbt;

      /* Create new database and fix it up */
      fdb = fopen(s, "w+b");
      if (!fdb) {
  free_null(s);
  free_null(npath);
  return NULL;
      }
      lockfile(fdb);
      fdbt.version = FILEDB_NEWEST_VER;
      fdbt.timestamp = now;
      filedb_writetop(fdb, &fdbt);
      filedb_update(npath, fdb, sort);
      count++;
      free_null(s);
      free_null(npath);
      return fdb;
    }
  }

  lockfile(fdb);      /* Lock it from other bots */
  filedb_readtop(fdb, &fdbt);
  if (fdbt.version < FILEDB_NEWEST_VER) {
    if (!convert_old_db(&fdb, s)) {
      /* Conversion failed. Unlock file again and error out.
       * (convert_old_db() could have modified fdb, so check
       * for fdb != NULL.)
       */
      if (fdb)
        unlockfile(fdb);
      free_null(npath);
      free_null(s);
      return NULL;
    }
    filedb_update(npath, fdb, sort);
  }
  stat(npath, &st);
  /* Update filedb if:
   * + it's been 6 hours since it was last updated
   * + the directory has been visibly modified since then
   * (6 hours may be a bit often)
   */
  if (sort || ((now - fdbt.timestamp) > (6 * 3600)) ||
      (fdbt.timestamp < st.st_mtime) ||
      (fdbt.timestamp < st.st_ctime))
    /* File database isn't up-to-date! */
    filedb_update(npath, fdb, sort & 1);
  else if ((now - fdbt.timestamp) > 300)
    filedb_mergeempty(fdb);

  count++;
  free_null(npath);
  free_null(s);
  return fdb;
}

static int filedb_readtop	(	FILE *	fdb,
		filedb_top *	fdbt
	)			[static]

Definition at line 210 of file filedb3.c.

Referenced by cmd_desc(), cmd_hide(), cmd_mkdir(), cmd_mv_cp(), cmd_reget_get(), cmd_rm(), cmd_rmdir(), cmd_unhide(), convert_old_db(), filedb_add(), filedb_change(), filedb_cleanup(), filedb_findempty(), filedb_getdirs(), filedb_getentry(), filedb_getfiles(), filedb_ls(), filedb_mergeempty(), filedb_open(), filedb_setdesc(), filedb_setowner(), filedb_timestamp(), filedb_update(), files_reget(), incr_file_gots(), resolve_dir(), tcl_mkdir(), tcl_mv_cp(), tcl_rmdir(), and tcl_setflags().

{
  if (fdbt) {
    /* Read header */
    fseek(fdb, 0L, SEEK_SET);
    if (feof(fdb))
      return 0;
    fread(fdbt, 1, sizeof(filedb_top), fdb);
  } else
    fseek(fdb, sizeof(filedb_top), SEEK_SET);
  return 1;
}

static void filedb_setdesc	(	char *	dir,
		char *	fn,
		char *	desc
	)			[static]

Definition at line 1095 of file filedb3.c.

References filedb_entry::desc, filedb_close(), filedb_matchfile, filedb_open(), filedb_readtop(), filedb_updatefile, free_fdbe(), NULL, filedb_entry::pos, and UPDATE_ALL.

Referenced by tcl_setdesc().

{
  filedb_entry *fdbe = NULL;
  FILE         *fdb  = NULL;

  fdb = filedb_open(dir, 0);
  if (!fdb)
    return;
  filedb_readtop(fdb, NULL);
  fdbe = filedb_matchfile(fdb, ftell(fdb), fn);
  if (fdbe) {
    free_null(fdbe->desc);
    realloc_strcpy(fdbe->desc, desc);
    filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_ALL);
    free_fdbe(&fdbe);
  }
  filedb_close(fdb);
}

static void filedb_setowner	(	char *	dir,
		char *	fn,
		char *	owner
	)			[static]

Definition at line 1114 of file filedb3.c.

References filedb_close(), filedb_matchfile, filedb_open(), filedb_readtop(), filedb_updatefile, free_fdbe(), NULL, filedb_entry::pos, UPDATE_ALL, and filedb_entry::uploader.

Referenced by tcl_setowner().

{
  filedb_entry *fdbe = NULL;
  FILE         *fdb  = NULL;

  fdb = filedb_open(dir, 0);
  if (!fdb)
    return;
  filedb_readtop(fdb, NULL);
  fdbe = filedb_matchfile(fdb, ftell(fdb), fn);
  if (fdbe) {
    free_null(fdbe->uploader);
    realloc_strcpy(fdbe->uploader, owner);
    filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_ALL);
    free_fdbe(&fdbe);
  }
  filedb_close(fdb);
}

static void filedb_timestamp

(

FILE *

fdb

)

[static]

Definition at line 663 of file filedb3.c.

References filedb_readtop(), filedb_writetop(), now, and filedb_top::timestamp.

Referenced by filedb_close(), and filedb_update().

{
  filedb_top fdbt;

  filedb_readtop(fdb, &fdbt);
  fdbt.timestamp = now;
  filedb_writetop(fdb, &fdbt);
}

static void filedb_update	(	char *	path,
		FILE *	fdb,
		int	sort
	)			[static]

Definition at line 678 of file filedb3.c.

References _, dirent, FILE_DIR, FILE_UNUSED, filedb_addfile, filedb_cleanup(), filedb_delfile(), filedb_getfile, filedb_matchfile, filedb_readtop(), filedb_timestamp(), filedb_updatefile, free_fdbe(), GET_FILENAME, LOG_MISC, malloc_fdbe, now, NULL, putlog(), and UPDATE_HEADER.

Referenced by filedb_open().

{
  struct dirent *dd = NULL;
  struct stat st;
  filedb_entry *fdbe = NULL;
  DIR *dir = NULL;
  long where = 0;
  char *name = NULL, *s = NULL;

  /*
   * FIRST: make sure every real file is in the database
   */
  dir = opendir(path);
  if (dir == NULL) {
    putlog(LOG_MISC, "*", _("filedb-update: cant open directory!"));
    return;
  }
  dd = readdir(dir);
  while (dd != NULL) {
    realloc_strcpy(name, dd->d_name);
    if (name[0] != '.') {
      s = malloc(strlen(path) + strlen(name) + 2);
      sprintf(s, "%s/%s", path, name);
      stat(s, &st);
      free_null(s);
      filedb_readtop(fdb, NULL);
      fdbe = filedb_matchfile(fdb, ftell(fdb), name);
      if (!fdbe) {
  /* new file! */
  fdbe = malloc_fdbe();
  realloc_strcpy(fdbe->filename, name);
  realloc_strcpy(fdbe->uploader, myname);
  fdbe->uploaded = now;
  fdbe->size = st.st_size;
  if (S_ISDIR(st.st_mode))
    fdbe->stat |= FILE_DIR;
  filedb_addfile(fdb, fdbe);
      } else if (fdbe->size != st.st_size) {
  /* update size if needed */
  fdbe->size = st.st_size;
  filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_HEADER);
      }
      free_fdbe(&fdbe);
    }
    dd = readdir(dir);
  }
  if (name)
    free_null(name);
  closedir(dir);

  /*
   * SECOND: make sure every db file is real
   */
  filedb_readtop(fdb, NULL);
  fdbe = filedb_getfile(fdb, ftell(fdb), GET_FILENAME);
  while (fdbe) {
    where = ftell(fdb);
    if (!(fdbe->stat & FILE_UNUSED) && !(fdbe->stat & FILE_ISLINK) &&
  fdbe->filename) {
      s = malloc(strlen(path) + 1 + strlen(fdbe->filename) + 1);
      sprintf(s, "%s/%s", path, fdbe->filename);
      if (stat(s, &st) != 0)
  /* gone file */
  filedb_delfile(fdb, fdbe->pos);
      free_null(s);
    }
    free_fdbe(&fdbe);
    fdbe = filedb_getfile(fdb, where, GET_FILENAME);
  }

  /*
   * THIRD: optimise database
   *
   * Instead of sorting, we only clean up the db, because sorting is now
   * done on-the-fly when we display the file list.
   */
  if (sort)
    filedb_cleanup(fdb);      /* Cleanup DB   */
  filedb_timestamp(fdb);      /* Write new timestamp  */
}

static int filedb_writetop	(	FILE *	fdb,
		filedb_top *	fdbt
	)			[static]

Definition at line 225 of file filedb3.c.

Referenced by filedb_initdb(), filedb_open(), and filedb_timestamp().

{
  fseek(fdb, 0L, SEEK_SET);
  fwrite(fdbt, 1, sizeof(filedb_top), fdb);
  return 1;
}

static void free_fdbe

(

filedb_entry **

fdbe

)

[static]

Definition at line 140 of file filedb3.c.

Referenced by _filedb_matchfile(), _filedb_updatefile(), cmd_desc(), cmd_hide(), cmd_mkdir(), cmd_mv_cp(), cmd_reget_get(), cmd_rm(), cmd_rmdir(), cmd_unhide(), convert_old_files(), convert_version1(), convert_version2(), filedb_add(), filedb_change(), filedb_cleanup(), filedb_findempty(), filedb_getdesc(), filedb_getdirs(), filedb_getfiles(), filedb_getgots(), filedb_getowner(), filedb_ls(), filedb_mergeempty(), filedb_setdesc(), filedb_setowner(), filedb_update(), files_reget(), incr_file_gots(), resolve_dir(), tcl_getflags(), tcl_mkdir(), tcl_mv_cp(), tcl_rmdir(), and tcl_setflags().

{
  if (!fdbe || !*fdbe)
    return;
  if ((*fdbe)->filename)
    free_null((*fdbe)->filename);
  if ((*fdbe)->desc)
    free_null((*fdbe)->desc);
  if ((*fdbe)->chan)
    free_null((*fdbe)->chan);
  if ((*fdbe)->uploader)
    free_null((*fdbe)->uploader);
  if ((*fdbe)->flags_req)
    free_null((*fdbe)->flags_req);
  free_null(*fdbe);
}

static void lockfile

(

FILE *

fdb

)

[static]

Definition at line 178 of file filedb3.c.

Referenced by convert_old_db(), convert_old_files(), and filedb_open().

{
  struct flock fl;

  fl.l_type = F_WRLCK;
  fl.l_start = 0;
  fl.l_whence = SEEK_SET;
  fl.l_len = 0;
  fcntl(fileno(fdb), F_SETLKW, &fl);
}

static char* make_point_path

(

char *

path

)

[static]

Definition at line 762 of file filedb3.c.

References NULL.

Referenced by filedb_open().

{
    char *s2 = NULL, *p = NULL;

    realloc_strcpy(s2, path);
    if (s2[strlen(s2) - 1] == '/')
      s2[strlen(s2) - 1] = 0;   /* remove trailing '/' */
    p = s2;
    while (*p++)
      if (*p == '/')
  *p = '.';
    return s2;
}

static void unlockfile

(

FILE *

f

)

[static]

Definition at line 191 of file filedb3.c.

Referenced by convert_old_db(), convert_old_files(), filedb_close(), and filedb_open().

{
  struct flock fl;

  fl.l_type = F_UNLCK;
  fl.l_start = 0;
  fl.l_whence = SEEK_SET;
  fl.l_len = 0;
  fcntl(fileno(f), F_SETLKW, &fl);
}

static int wild_match_file	(	register char *	m,
		register char *	n
	)			[static]

Definition at line 80 of file filedb3.c.

References FILEMATCH, FILEQUOTE, FILEWILDQ, and FILEWILDS.

Referenced by _filedb_matchfile(), and filedb_ls().

{
  char *ma = m, *lsm = 0, *lsn = 0;
  int match = 1;
  register unsigned int sofar = 0;

  /* null strings should never match */
  if ((m == 0) || (n == 0) || (!*n))
    return 0;

  while (*n) {
    switch (*m) {
    case 0:
      do
  m--;
      while ((m > ma) && (*m == '?'));
      if ((m > ma) ? ((*m == '*') && (m[-1] != FILEQUOTE)) : (*m == '*'))
  return FILEMATCH;
      break;
    case FILEWILDS:
      do
  m++;
      while (*m == FILEWILDS);
      lsm = m;
      lsn = n;
      match += sofar;
      sofar = 0;
      continue;
    case FILEWILDQ:
      m++;
      n++;
      continue;
    case FILEQUOTE:
      m++;
    }
    if (*m == *n) {
      m++;
      n++;
      sofar++;
      continue;
    }
    if (lsm) {
      n = ++lsn;
      m = lsm;
      sofar = 0;
      continue;
    }
    return 0;
  }
  while (*m == FILEWILDS)
    m++;
  return (*m) ? 0 : MATCH;
}

---

Variable Documentation

int count = 0 [static]

Definition at line 73 of file filedb3.c.

Referenced by filedb_close(), filedb_open(), my_perl_callbacker(), wild_match(), and wild_match_per().