src/mod/filesys.mod/filedb3.c File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines
#define	filedb_read(fdb, entry, len)
Functions
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	remote_filereq (int idx, char *from, char *file)
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_setlink (char *dir, char *fn, char *link)
static void	filedb_getlink (char *dir, char *fn, char **link)
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, int what)
Variables
static int	count = 0

---

Define Documentation

#define filedb_read	(	fdb,
		entry,
		len		)

Value:

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

Definition at line 414 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 404 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;
}

Here is the call graph for this function:

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

Definition at line 427 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_ISLINK, 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_entry::sharelink, filedb_header::sharelink_len, 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           */

  /* This is useful for cases where we don't read the rest of the
   * data, but need to know whether the file is a link.
   */
  if (fdh.sharelink_len > 0)
    fdbe->stat |= FILE_ISLINK;
  else
    fdbe->stat &= ~FILE_ISLINK;

  /* 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);
    filedb_read(fdb, fdbe->sharelink, fdh.sharelink_len);
  }
  fseek(fdb, fdh.buffer_len, SEEK_CUR); /* Skip buffer                  */
  return fdbe;                  /* Return the ready structure   */
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 482 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;
}

Here is the call graph for this function:

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

Definition at line 394 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;
}

Here is the call graph for this function:

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

Definition at line 274 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, egg_bzero, 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::sharelink, filedb_header::sharelink_len, 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;

  egg_bzero(&fdh, 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;
  if (fdbe->sharelink)
    fdh.sharelink_len = strlen(fdbe->sharelink) + 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);
    if (fdbe->sharelink)
      fwrite(fdbe->sharelink, 1, fdh.sharelink_len, fdb);
  } else
    fseek(fdb, ndyntot, SEEK_CUR);      /* Skip over dynamic data */
  fseek(fdb, nbuftot, SEEK_CUR);        /* Skip over buffer       */
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 100 of file filedb3.c.

References filedb_entry::_type, egg_bzero, global, MODULE_NAME, nmalloc, NULL, and TYPE_NEW.

Referenced by _filedb_getfile().

{
  filedb_entry *fdbe = NULL;

#ifdef DEBUG_MEM
  /* This is a hack to access the nmalloc function with
   * special file and line information
   */
  fdbe = (((void *(*)())global[0])(sizeof(filedb_entry),MODULE_NAME,file,line));
#else
  fdbe = nmalloc(sizeof(filedb_entry));
#endif
  egg_bzero(fdbe, sizeof(filedb_entry));

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

Here is the caller graph for this function:

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

Definition at line 848 of file filedb3.c.

References filedb_matchfile, filedb_readtop(), filedb_updatefile, free_fdbe(), malloc_strcpy, my_free, 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;
  my_free(fdbe->uploader);
  malloc_strcpy(fdbe->uploader, nick);
  fdbe->uploaded = now;
  filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_ALL);
  free_fdbe(&fdbe);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1268 of file filedb3.c.

References FILE_DIR, FILE_HIDDEN, FILE_SHARE, filedb_close(), FILEDB_HIDE, filedb_matchfile, filedb_open(), filedb_readtop(), FILEDB_SHARE, FILEDB_UNHIDE, FILEDB_UNSHARE, filedb_updatefile, free_fdbe(), NULL, filedb_entry::pos, filedb_entry::stat, and UPDATE_HEADER.

{
  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)) {
      switch (what) {
      case FILEDB_SHARE:
        fdbe->stat |= FILE_SHARE;
        break;
      case FILEDB_UNSHARE:
        fdbe->stat &= ~FILE_SHARE;
        break;
      }
      changed = 1;
    }
    switch (what) {
    case FILEDB_HIDE:
      fdbe->stat |= FILE_HIDDEN;
      changed = 1;
      break;
    case FILEDB_UNHIDE:
      fdbe->stat &= ~FILE_HIDDEN;
      changed = 1;
      break;
    }
    if (changed)
      filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_HEADER);
    free_fdbe(&fdbe);
  }
  filedb_close(fdb);
}

Here is the call graph for this function:

static void filedb_cleanup

(

FILE *

fdb

)

[static]

Definition at line 507 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    */
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void filedb_close

(

FILE *

fdb

)

[static]

Definition at line 835 of file filedb3.c.

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

Referenced by add_file(), cmd_desc(), cmd_hide(), cmd_ln(), cmd_mkdir(), cmd_mv_cp(), cmd_optimize(), cmd_reget_get(), cmd_rm(), cmd_rmdir(), cmd_share(), cmd_unhide(), cmd_unshare(), filedb_change(), filedb_getdirs(), filedb_getentry(), filedb_getfiles(), filedb_setdesc(), filedb_setlink(), filedb_setowner(), files_ls(), files_reget(), incr_file_gots(), remote_filereq(), resolve_dir(), and welcome_to_files().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 185 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_setlink(), and filedb_update().

{
  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;
}

Here is the caller graph for this function:

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

Definition at line 218 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1100 of file filedb3.c.

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

{
  filedb_entry *fdbe = NULL;

  fdbe = filedb_getentry(dir, fn);
  if (fdbe) {
    if (fdbe->desc) {
      *desc = nmalloc(strlen(fdbe->desc) + 1);
      strcpy(*desc, fdbe->desc);
    }
    free_fdbe(&fdbe);
  } else
    *desc = NULL;
}

Here is the call graph for this function:

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

Definition at line 1248 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.

{
  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);
}

Here is the call graph for this function:

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

Definition at line 596 of file filedb3.c.

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

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

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1228 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.

{
  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);
}

Here is the call graph for this function:

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

Definition at line 1128 of file filedb3.c.

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

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

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

Here is the call graph for this function:

static void filedb_getlink	(	char *	dir,
		char *	fn,
		char **	link
	)			[static]

Definition at line 1214 of file filedb3.c.

References FILE_DIR, filedb_getentry(), free_fdbe(), malloc_strcpy, NULL, filedb_entry::sharelink, and filedb_entry::stat.

{
  filedb_entry *fdbe = NULL;

  fdbe = filedb_getentry(dir, fn);
  if (fdbe && (!(fdbe->stat & FILE_DIR))) {
    malloc_strcpy(*link, fdbe->sharelink);
  } else
    *link = NULL;
  if (fdbe)
    free_fdbe(&fdbe);
  return;
}

Here is the call graph for this function:

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

Definition at line 1115 of file filedb3.c.

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

{
  filedb_entry *fdbe = NULL;

  fdbe = filedb_getentry(dir, fn);
  if (fdbe) {
    *owner = nmalloc(strlen(fdbe->uploader) + 1);
    strcpy(*owner, fdbe->uploader);
    free_fdbe(&fdbe);
  } else
    *owner = NULL;
}

Here is the call graph for this function:

static void filedb_initdb

(

FILE *

fdb

)

[static]

Definition at line 612 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 867 of file filedb3.c.

References break_down_flags, filedb_entry::chan, dcc, filedb_entry::desc, dprintf, egg_strftime(), FILE_DIR, FILE_HIDDEN, FILE_SHARE, FILE_UNUSED, filedb_getfile, filedb_readtop(), filelist_add(), filelist_addout(), filelist_free(), filelist_idxshow(), filelist_new(), filelist_sort(), filedb_entry::filename, FILES_LSHEAD1, FILES_LSHEAD2, FILES_NOFILES, FILES_NOMATCH, FILES_REQUIRES, flagrec_ok, filedb_entry::flags_req, FR_CHAN, FR_GLOBAL, free_fdbe(), GET_FULL, get_user_flagrec, flag_record::global, filedb_entry::gots, malloc_strcpy, my_free, nmalloc, NULL, filedb_entry::sharelink, filedb_entry::size, filedb_entry::stat, filedb_entry::uploaded, filedb_entry::uploader, USER_JANITOR, USER_MASTER, 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, FILES_LSHEAD1);
        dprintf(idx, FILES_LSHEAD2);
      }
      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 = nmalloc(strlen(fdbe->filename) + 3);
          sprintf(s2, "%s/\n", fdbe->filename);
          filelist_addout(flist, s2);
          my_free(s2);
        } else {
          s2 = nmalloc(strlen(fdbe->filename) + 2);
          sprintf(s2, "%s/", fdbe->filename);
        }
        /* Note: You have to keep the sprintf and the nmalloc statements
         *       in sync, i.e. always check that you allocate enough
         *       memory.
         */
        if ((fdbe->flags_req) && (user.global &(USER_MASTER | USER_JANITOR))) {
          s3 = nmalloc(42 + strlen(s2 ? s2 : "") + 6 +
                       strlen(FILES_REQUIRES) + strlen(fdbe->flags_req) + 1 +
                       strlen(fdbe->chan ? fdbe->chan : "") + 1);
          sprintf(s3, "%-30s <DIR%s>  (%s %s%s%s)\n", s2,
                  fdbe->stat & FILE_SHARE ?
                  " SHARE" : "", FILES_REQUIRES, fdbe->flags_req,
                  fdbe->chan ? " " : "", fdbe->chan ? fdbe->chan : "");
        } else {
          s3 = nmalloc(38 + strlen(s2 ? s2 : ""));
          sprintf(s3, "%-30s <DIR>\n", s2 ? s2 : "");
        }
        if (s2)
          my_free(s2);
        filelist_addout(flist, s3);
        my_free(s3);
      } else {
        char s2[41], t[50], *s3 = NULL, *s4;

        s2[0] = 0;
        if (showall) {
          if (fdbe->stat & FILE_SHARE)
            strcat(s2, " (shr)");
          if (fdbe->stat & FILE_HIDDEN)
            strcat(s2, " (hid)");
        }
        egg_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));
        if (fdbe->sharelink)
          strcpy(s1, "     ");
        /* Too long? */
        if (strlen(fdbe->filename) > 30) {
          s3 = nmalloc(strlen(fdbe->filename) + 2);
          sprintf(s3, "%s\n", fdbe->filename);
          filelist_addout(flist, s3);
          my_free(s3);
          /* Causes filename to be displayed on its own line */
        } else
          malloc_strcpy(s3, fdbe->filename);
        s4 = nmalloc(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)
          my_free(s3);
        filelist_addout(flist, s4);
        my_free(s4);
        if (fdbe->sharelink) {
          s4 = nmalloc(9 + strlen(fdbe->sharelink));
          sprintf(s4, "   --> %s\n", fdbe->sharelink);
          filelist_addout(flist, s4);
          my_free(s4);
        }
      }
      if (fdbe->desc) {
        p = strchr(fdbe->desc, '\n');
        while (p != NULL) {
          *p = 0;
          if ((fdbe->desc)[0]) {
            char *sd;

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

          sd = nmalloc(strlen(fdbe->desc) + 5);
          sprintf(sd, "   %s\n", fdbe->desc);
          filelist_addout(flist, sd);
          my_free(sd);
        }
      }
      cnt++;
    }
    free_fdbe(&fdbe);
    fdbe = filedb_getfile(fdb, ftell(fdb), GET_FULL);
  }
  if (is == 0)
    dprintf(idx, FILES_NOFILES);
  else if (cnt == 0)
    dprintf(idx, FILES_NOMATCH);
  else {
    filelist_sort(flist);
    filelist_idxshow(flist, idx);
    dprintf(idx, "--- %d file%s.\n", cnt, cnt != 1 ? "s" : "");
  }
  filelist_free(flist);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void filedb_mergeempty

(

FILE *

fdb

)

[static]

Definition at line 547 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);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 736 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(), FILES_NOCONVERT, lockfile(), LOG_MISC, make_point_path(), my_free, nmalloc, now, NULL, putlog, simple_sprintf, filedb_top::timestamp, unlockfile(), and filedb_top::version.

Referenced by add_file(), cmd_desc(), cmd_hide(), cmd_ln(), cmd_mkdir(), cmd_mv_cp(), cmd_optimize(), cmd_reget_get(), cmd_rm(), cmd_rmdir(), cmd_share(), cmd_unhide(), cmd_unshare(), filedb_change(), filedb_getdirs(), filedb_getentry(), filedb_getfiles(), filedb_setdesc(), filedb_setlink(), filedb_setowner(), files_ls(), files_reget(), incr_file_gots(), remote_filereq(), resolve_dir(), 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 = nmalloc(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 = nmalloc(strlen(filedb_path) + strlen(s2) + 8);
    simple_sprintf(s, "%sfiledb.%s", filedb_path, s2);
    my_free(s2);
  } else {
    s = nmalloc(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, "*", FILES_NOCONVERT, npath);
        my_free(s);
        my_free(npath);
        return NULL;
      }
      lockfile(fdb);
      filedb_update(npath, fdb, sort);
      count++;
      my_free(s);
      my_free(npath);
      return fdb;
    } else {
      filedb_top fdbt;

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 159 of file filedb3.c.

Referenced by cmd_desc(), cmd_hide(), cmd_ln(), cmd_mkdir(), cmd_mv_cp(), cmd_reget_get(), cmd_rm(), cmd_rmdir(), cmd_share(), cmd_unhide(), cmd_unshare(), 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_setlink(), filedb_setowner(), filedb_timestamp(), filedb_update(), files_reget(), incr_file_gots(), remote_filereq(), and resolve_dir().

{
  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;
}

Here is the caller graph for this function:

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

Definition at line 1141 of file filedb3.c.

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

{
  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) {
    my_free(fdbe->desc);
    malloc_strcpy(fdbe->desc, desc);
    filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_ALL);
    free_fdbe(&fdbe);
  }
  filedb_close(fdb);
}

Here is the call graph for this function:

static void filedb_setlink	(	char *	dir,
		char *	fn,
		char *	link
	)			[static]

Definition at line 1179 of file filedb3.c.

References botnetnick, FILE_DIR, filedb_addfile, filedb_close(), filedb_delfile(), filedb_matchfile, filedb_open(), filedb_readtop(), filedb_updatefile, filedb_entry::filename, free_fdbe(), malloc_fdbe, malloc_strcpy, my_free, now, NULL, filedb_entry::pos, filedb_entry::sharelink, filedb_entry::stat, UPDATE_ALL, filedb_entry::uploaded, and filedb_entry::uploader.

{
  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) {
    /* Change existing one? */
    if ((fdbe->stat & FILE_DIR) || !fdbe->sharelink)
      return;
    if (!link || !link[0])
      filedb_delfile(fdb, fdbe->pos);
    else {
      my_free(fdbe->sharelink);
      malloc_strcpy(fdbe->sharelink, link);
      filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_ALL);
    }
    free_fdbe(&fdbe);
    return;
  }

  fdbe = malloc_fdbe();
  malloc_strcpy(fdbe->uploader, botnetnick);
  malloc_strcpy(fdbe->filename, fn);
  malloc_strcpy(fdbe->sharelink, link);
  fdbe->uploaded = now;
  filedb_addfile(fdb, fdbe);
  free_fdbe(&fdbe);
  filedb_close(fdb);
}

Here is the call graph for this function:

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

Definition at line 1160 of file filedb3.c.

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

{
  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) {
    my_free(fdbe->uploader);
    malloc_strcpy(fdbe->uploader, owner);
    filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_ALL);
    free_fdbe(&fdbe);
  }
  filedb_close(fdb);
}

Here is the call graph for this function:

static void filedb_timestamp

(

FILE *

fdb

)

[static]

Definition at line 621 of file filedb3.c.

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

Referenced by filedb_close(), and filedb_update().

{
  filedb_top fdbt;

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 636 of file filedb3.c.

References botnetnick, dirent, FILE_DIR, FILE_ISLINK, FILE_UNUSED, filedb_addfile, filedb_cleanup(), filedb_delfile(), filedb_getfile, filedb_matchfile, filedb_readtop(), filedb_timestamp(), filedb_updatefile, FILES_NOUPDATE, free_fdbe(), GET_FILENAME, LOG_MISC, malloc_fdbe, malloc_strcpy, my_free, nmalloc, now, NULL, putlog, S_ISDIR, 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, "*", FILES_NOUPDATE);
    return;
  }
  dd = readdir(dir);
  while (dd != NULL) {
    malloc_strcpy(name, dd->d_name);
    if (name[0] != '.') {
      s = nmalloc(strlen(path) + strlen(name) + 2);
      sprintf(s, "%s/%s", path, name);
      stat(s, &st);
      my_free(s);
      filedb_readtop(fdb, NULL);
      fdbe = filedb_matchfile(fdb, ftell(fdb), name);
      if (!fdbe) {
        /* new file! */
        fdbe = malloc_fdbe();
        malloc_strcpy(fdbe->filename, name);
        malloc_strcpy(fdbe->uploader, botnetnick);
        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)
    my_free(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 = nmalloc(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);
      my_free(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  */
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 174 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;
}

Here is the caller graph for this function:

static void free_fdbe

(

filedb_entry **

fdbe

)

[static]

Definition at line 79 of file filedb3.c.

References my_free.

Referenced by _filedb_matchfile(), _filedb_updatefile(), cmd_desc(), cmd_hide(), cmd_ln(), cmd_mkdir(), cmd_mv_cp(), cmd_reget_get(), cmd_rm(), cmd_rmdir(), cmd_share(), cmd_unhide(), cmd_unshare(), convert_old_files(), convert_version1(), convert_version2(), filedb_add(), filedb_change(), filedb_cleanup(), filedb_findempty(), filedb_getdesc(), filedb_getdirs(), filedb_getfiles(), filedb_getgots(), filedb_getlink(), filedb_getowner(), filedb_ls(), filedb_mergeempty(), filedb_setdesc(), filedb_setlink(), filedb_setowner(), filedb_update(), files_reget(), incr_file_gots(), remote_filereq(), and resolve_dir().

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

Here is the caller graph for this function:

static void lockfile

(

FILE *

fdb

)

[static]

Definition at line 127 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);
}

Here is the caller graph for this function:

static char* make_point_path

(

char *

path

)

[static]

Definition at line 720 of file filedb3.c.

References malloc_strcpy, and NULL.

Referenced by filedb_open().

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

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

Here is the caller graph for this function:

static void remote_filereq	(	int	idx,
		char *	from,
		char *	file
	)			[static]

Definition at line 1021 of file filedb3.c.

References botnet_send_filereject, botnet_send_filesend, botnetnick, copy_to_tmp, copyfile, dcc, dcc_total, dccdir, FILE_DIR, FILE_HIDDEN, FILE_SHARE, filedb_close(), filedb_matchfile, filedb_open(), filedb_readtop(), FILES_DIRDNE, FILES_FILEDNE, FILES_NOSHARE, FILES_REMOTE, FILES_REMOTEREQ, FILES_SENDERR, free_fdbe(), getmyip, iptolong, LOG_FILES, malloc_strcpy, my_free, nmalloc, NULL, putlog, raw_dcc_send(), simple_sprintf, filedb_entry::stat, tempdir, and wipe_tmp_filename().

{
  char *p = NULL, *what = NULL, *dir = NULL,
    *s1 = NULL, *reject = NULL, *s = NULL;
  FILE *fdb = NULL;
  int i = 0;
  filedb_entry *fdbe = NULL;

  malloc_strcpy(what, file);
  p = strrchr(what, '/');
  if (p) {
    *p = 0;
    malloc_strcpy(dir, what);
    strcpy(what, p + 1);
  } else {
    malloc_strcpy(dir, "");
  }
  fdb = filedb_open(dir, 0);
  if (!fdb) {
    reject = FILES_DIRDNE;
  } else {
    filedb_readtop(fdb, NULL);
    fdbe = filedb_matchfile(fdb, ftell(fdb), what);
    filedb_close(fdb);
    if (!fdbe) {
      reject = FILES_FILEDNE;
    } else {
      if ((!(fdbe->stat & FILE_SHARE)) ||
          (fdbe->stat & (FILE_HIDDEN | FILE_DIR)))
        reject = FILES_NOSHARE;
      else {
        s1 = nmalloc(strlen(dccdir) + strlen(dir) + strlen(what) + 2);
        /* Copy to /tmp if needed */
        sprintf(s1, "%s%s%s%s", dccdir, dir, dir[0] ? "/" : "", what);
        if (copy_to_tmp) {
          s = nmalloc(strlen(tempdir) + strlen(what) + 1);
          sprintf(s, "%s%s", tempdir, what);
          copyfile(s1, s);
        } else
          s = s1;
        i = raw_dcc_send(s, "*remote", FILES_REMOTE, s);
        if (i > 0) {
          wipe_tmp_filename(s, -1);
          reject = FILES_SENDERR;
        }
        if (s1 != s)
          my_free(s);
        my_free(s1);
      }
      free_fdbe(&fdbe);
    }
  }
  s1 = nmalloc(strlen(botnetnick) + strlen(dir) + strlen(what) + 3);
  simple_sprintf(s1, "%s:%s/%s", botnetnick, dir, what);
  if (reject) {
    botnet_send_filereject(idx, s1, from, reject);
    my_free(s1);
    my_free(what);
    my_free(dir);
    return;
  }
  /* Grab info from dcc struct and bounce real request across net */
  i = dcc_total - 1;
  s = nmalloc(40);              /* Enough? */
  simple_sprintf(s, "%d %u %d", iptolong(getmyip()), dcc[i].port,
                 dcc[i].u.xfer->length);
  botnet_send_filesend(idx, s1, from, s);
  putlog(LOG_FILES, "*", FILES_REMOTEREQ, dir, dir[0] ? "/" : "", what);
  my_free(s1);
  my_free(s);
  my_free(what);
  my_free(dir);
}

Here is the call graph for this function:

static void unlockfile

(

FILE *

f

)

[static]

Definition at line 140 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);
}

Here is the caller graph for this function:

---

Variable Documentation

int count = 0 [static]

Definition at line 70 of file filedb3.c.

Referenced by check_ansi(), detect_avalanche(), filedb_close(), filedb_open(), minutely_checks(), set_delay(), status_tbufs(), and wire_report().