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

#include "src/stat.h"

Include dependency graph for files.c:

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

Go to the source code of this file.

Defines
#define	dirent   direct
#define	NAMLEN(dirent)   (dirent)->d_namlen
Functions
static int	too_many_filers ()
static void	add_file (char *dir, char *file, char *nick)
static int	welcome_to_files (int idx)
static void	cmd_optimize (int idx, char *par)
static int	resolve_dir (char *current, char *change, char **real, int idx)
static void	incr_file_gots (char *ppath)
static void	cmd_pwd (int idx, char *par)
static void	cmd_pending (int idx, char *par)
static void	cmd_cancel (int idx, char *par)
static void	cmd_chdir (int idx, char *msg)
static void	files_ls (int idx, char *par, int showall)
static void	cmd_ls (int idx, char *par)
static void	cmd_lsa (int idx, char *par)
static void	cmd_reget_get (int idx, char *par, int resend)
static void	cmd_reget (int idx, char *par)
static void	cmd_get (int idx, char *par)
static void	cmd_file_help (int idx, char *par)
static void	cmd_hide (int idx, char *par)
static void	cmd_unhide (int idx, char *par)
static void	cmd_share (int idx, char *par)
static void	cmd_unshare (int idx, char *par)
static void	cmd_ln (int idx, char *par)
static void	cmd_desc (int idx, char *par)
static void	cmd_rm (int idx, char *par)
static void	cmd_mkdir (int idx, char *par)
static void	cmd_rmdir (int idx, char *par)
static void	cmd_mv_cp (int idx, char *par, int copy)
static void	cmd_mv (int idx, char *par)
static void	cmd_cp (int idx, char *par)
static int	cmd_stats (int idx, char *par)
static int	cmd_filestats (int idx, char *par)
static void	filesys_note (int idx, char *par)
static int	files_reget (int idx, char *fn, char *nick, int resend)
static void	files_setpwd (int idx, char *where)
Variables
static cmd_t	myfiles []

---

Define Documentation

#define dirent   direct

Definition at line 30 of file files.c.

Referenced by filedb_update().

#define NAMLEN

(

dirent

)

(dirent)->d_namlen

Definition at line 31 of file files.c.

---

Function Documentation

static void add_file	(	char *	dir,
		char *	file,
		char *	nick
	)			[static]

Definition at line 62 of file files.c.

References dccdir, filedb_add(), filedb_close(), and filedb_open().

{
  FILE *f;

  /* Gave me a full pathname.
   * Only continue if the destination is within the visible file system.
   */
  if (!strncmp(dccdir, dir, strlen(dccdir)) &&
      (f = filedb_open(&dir[strlen(dccdir)], 2))) {
    filedb_add(f, file, nick);
    filedb_close(f);
  }
}

Here is the call graph for this function:

static void cmd_cancel	(	int	idx,
		char *	par
	)			[static]

Definition at line 327 of file files.c.

References dcc, dprintf, fileq_cancel(), LOG_FILES, MISC_USAGE, and putlog.

{
  if (!par[0]) {
    dprintf(idx, "%s: cancel <file-mask>\n", MISC_USAGE);
    return;
  }
  fileq_cancel(idx, par);
  putlog(LOG_FILES, "*", "files: #%s# cancel %s", dcc[idx].nick, par);
}

Here is the call graph for this function:

static void cmd_chdir	(	int	idx,
		char *	msg
	)			[static]

Definition at line 337 of file files.c.

References dcc, dprintf, FILES_NEWCURDIR, FILES_NOSUCHDIR, LOG_FILES, MISC_USAGE, my_free, NULL, putlog, resolve_dir(), set_user, user, and USERENTRY_DCCDIR.

{
  char *s = NULL;

  if (!msg[0]) {
    dprintf(idx, "%s: cd <new-dir>\n", MISC_USAGE);
    return;
  }
  if (!resolve_dir(dcc[idx].u.file->dir, msg, &s, idx)) {
    dprintf(idx, FILES_NOSUCHDIR);
    my_free(s);
    return;
  }
  strncpy(dcc[idx].u.file->dir, s, 160);
  my_free(s);
  dcc[idx].u.file->dir[160] = 0;
  set_user(&USERENTRY_DCCDIR, dcc[idx].user, dcc[idx].u.file->dir);
  putlog(LOG_FILES, "*", "files: #%s# cd /%s", dcc[idx].nick,
         dcc[idx].u.file->dir);
  dprintf(idx, "%s: /%s\n", FILES_NEWCURDIR, dcc[idx].u.file->dir);
}

Here is the call graph for this function:

static void cmd_cp	(	int	idx,
		char *	par
	)			[static]

Definition at line 1299 of file files.c.

References cmd_mv_cp().

{
  cmd_mv_cp(idx, par, 1);
}

Here is the call graph for this function:

static void cmd_desc	(	int	idx,
		char *	par
	)			[static]

Definition at line 791 of file files.c.

References dcc, filedb_entry::desc, dprintf, egg_strcasecmp, FILE_HIDDEN, filedb_close(), filedb_matchfile, filedb_open(), filedb_readtop(), filedb_updatefile, filedb_entry::filename, FILES_BLANKED, FILES_CHANGED, FILES_NOMATCH, FILES_NOTOWNER, free_fdbe(), LOG_FILES, malloc_strcpy, MISC_USAGE, my_free, newsplit, nmalloc, NULL, filedb_entry::pos, putlog, filedb_entry::stat, UPDATE_ALL, filedb_entry::uploader, user, and USER_JANITOR.

{
  char *fn, *desc, *p, *q;
  int ok = 0, lin;
  FILE *fdb;
  filedb_entry *fdbe;
  long where;

  fn = newsplit(&par);
  if (!fn[0]) {
    dprintf(idx, "%s: desc <filename> <new description>\n", MISC_USAGE);
    return;
  }
  /* Fix up desc */
  desc = nmalloc(strlen(par) + 2);
  strcpy(desc, par);
  strcat(desc, "|");
  /* Replace | with linefeeds, limit 5 lines */
  lin = 0;
  q = desc;
  while ((*q <= 32) && (*q))
    strcpy(q, &q[1]);           /* Zapf leading spaces */
  p = strchr(q, '|');
  while (p != NULL) {
    /* Check length */
    *p = 0;
    if (strlen(q) > 60) {
      /* Cut off at last space or truncate */
      *p = '|';
      p = q + 60;
      while ((*p != ' ') && (p != q))
        p--;
      if (p == q)
        *(q + 60) = '|';        /* No space, so truncate it */
      else
        *p = '|';
      p = strchr(q, '|');       /* Go back, find my place, and continue */
    }
    *p = '\n';
    q = p + 1;
    lin++;
    while ((*q <= 32) && (*q))
      strcpy(q, &q[1]);
    if (lin == 5) {
      *p = 0;
      p = NULL;
    } else
      p = strchr(q, '|');
  }
  if (desc[strlen(desc) - 1] == '\n')
    desc[strlen(desc) - 1] = 0;
  fdb = filedb_open(dcc[idx].u.file->dir, 0);
  if (!fdb) {
    my_free(desc);
    return;
  }
  filedb_readtop(fdb, NULL);
  fdbe = filedb_matchfile(fdb, ftell(fdb), fn);
  if (!fdbe) {
    filedb_close(fdb);
    dprintf(idx, FILES_NOMATCH);
    my_free(desc);
    return;
  }
  while (fdbe) {
    where = ftell(fdb);
    if (!(fdbe->stat & FILE_HIDDEN)) {
      ok = 1;
      if ((!(dcc[idx].user->flags & USER_JANITOR)) &&
          (egg_strcasecmp(fdbe->uploader, dcc[idx].nick)))
        dprintf(idx, FILES_NOTOWNER, fdbe->filename);
      else {
        if (desc[0]) {
          /* If the current description is the same as the new
           * one, don't change anything.
           */
          if (fdbe->desc && !strcmp(fdbe->desc, desc)) {
            free_fdbe(&fdbe);
            fdbe = filedb_matchfile(fdb, where, fn);
            continue;
          }
          malloc_strcpy(fdbe->desc, desc);
        } else if (fdbe->desc) {
          my_free(fdbe->desc);
        }
        filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_ALL);
        if (par[0])
          dprintf(idx, "%s: %s\n", FILES_CHANGED, fdbe->filename);
        else
          dprintf(idx, "%s: %s\n", FILES_BLANKED, fdbe->filename);
      }
    }
    free_fdbe(&fdbe);
    fdbe = filedb_matchfile(fdb, where, fn);
  }
  filedb_close(fdb);
  if (!ok)
    dprintf(idx, FILES_NOMATCH);
  else
    putlog(LOG_FILES, "*", "files: #%s# desc %s", dcc[idx].nick, fn);
  my_free(desc);
}

Here is the call graph for this function:

static void cmd_file_help	(	int	idx,
		char *	par
	)			[static]

Definition at line 534 of file files.c.

References dcc, FR_CHAN, FR_GLOBAL, get_user_flagrec, LOG_FILES, my_free, nmalloc, putlog, tellhelp, and user.

{
  char *s;
  struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };

  get_user_flagrec(dcc[idx].user, &fr, dcc[idx].u.file->chat->con_chan);
  if (par[0]) {
    putlog(LOG_FILES, "*", "files: #%s# help %s", dcc[idx].nick, par);
    s = nmalloc(strlen(par) + 9);
    sprintf(s, "filesys/%s", par);
    s[256] = 0;
    tellhelp(idx, s, &fr, 0);
    my_free(s);
  } else {
    putlog(LOG_FILES, "*", "files: #%s# help", dcc[idx].nick);
    tellhelp(idx, "filesys/help", &fr, 0);
  }
}

static int cmd_filestats	(	int	idx,
		char *	par
	)			[static]

Definition at line 1311 of file files.c.

References dcc, dprintf, get_user_by_handle, LOG_FILES, newsplit, NULL, putlog, set_user, tell_file_stats(), user, USER_JANITOR, USERENTRY_FSTAT, and userlist.

{
  char *nick;
  struct userrec *u;

  if (!par[0]) {
    dprintf(idx, "Usage: filestats <user>\n");
    return 0;
  }
  nick = newsplit(&par);
  putlog(LOG_FILES, "*", "#%s# filestats %s", dcc[idx].nick, nick);
  if (nick[0] == 0)
    tell_file_stats(idx, dcc[idx].nick);
  else if (!(u = get_user_by_handle(userlist, nick)))
    dprintf(idx, "No such user.\n");
  else if (!strcmp(par, "clear") && dcc[idx].user &&
           (dcc[idx].user->flags & USER_JANITOR)) {
    set_user(&USERENTRY_FSTAT, u, NULL);
    dprintf(idx, "Cleared filestats for %s.\n", nick);
  } else
    tell_file_stats(idx, nick);
  return 0;
}

Here is the call graph for this function:

static void cmd_get	(	int	idx,
		char *	par
	)			[static]

Definition at line 529 of file files.c.

References cmd_reget_get().

{
  cmd_reget_get(idx, par, 0);
}

Here is the call graph for this function:

static void cmd_hide	(	int	idx,
		char *	par
	)			[static]

Definition at line 553 of file files.c.

References dcc, dprintf, FILE_HIDDEN, filedb_close(), filedb_matchfile, filedb_open(), filedb_readtop(), filedb_updatefile, filedb_entry::filename, FILES_HID, FILES_NOMATCH, free_fdbe(), LOG_FILES, MISC_USAGE, NULL, filedb_entry::pos, putlog, filedb_entry::stat, and UPDATE_HEADER.

{
  FILE *fdb;
  filedb_entry *fdbe;
  long where = 0;
  int ok = 0;

  if (!par[0]) {
    dprintf(idx, "%s: hide <file(s)>\n", MISC_USAGE);
    return;
  }
  fdb = filedb_open(dcc[idx].u.file->dir, 0);
  if (!fdb)
    return;
  filedb_readtop(fdb, NULL);
  fdbe = filedb_matchfile(fdb, ftell(fdb), par);
  if (!fdbe) {
    filedb_close(fdb);
    dprintf(idx, FILES_NOMATCH);
    return;
  }
  while (fdbe) {
    where = ftell(fdb);
    if (!(fdbe->stat & FILE_HIDDEN)) {
      fdbe->stat |= FILE_HIDDEN;
      ok++;
      dprintf(idx, "%s: %s\n", FILES_HID, fdbe->filename);
      filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_HEADER);
    }
    free_fdbe(&fdbe);
    fdbe = filedb_matchfile(fdb, where, par);
  }
  filedb_close(fdb);
  if (!ok)
    dprintf(idx, FILES_NOMATCH);
  else {
    putlog(LOG_FILES, "*", "files: #%s# hide %s", dcc[idx].nick, par);
    if (ok > 1)
      dprintf(idx, "%s %d file%s.\n", FILES_HID, ok, ok == 1 ? "" : "s");
  }
}

Here is the call graph for this function:

static void cmd_ln	(	int	idx,
		char *	par
	)			[static]

Definition at line 724 of file files.c.

References dcc, dprintf, filedb_addfile, filedb_close(), filedb_matchfile, filedb_open(), filedb_readtop(), filedb_updatefile, filedb_entry::filename, FILES_ADDLINK, FILES_CHGLINK, FILES_NORMAL, FILES_NOSUCHDIR, free_fdbe(), LOG_FILES, malloc_fdbe, malloc_strcpy, MISC_USAGE, my_free, newsplit, now, NULL, filedb_entry::pos, putlog, resolve_dir(), filedb_entry::sharelink, UPDATE_ALL, filedb_entry::uploaded, and filedb_entry::uploader.

{
  char *share, *newpath = NULL, *newfn = NULL, *p;
  FILE *fdb;
  filedb_entry *fdbe;

  share = newsplit(&par);
  if (strlen(share) > 60)
    share[60] = 0;
  /* Correct format? */
  if (!(p = strchr(share, ':')) || !par[0])
    dprintf(idx, "%s: ln <bot:path> <localfile>\n", MISC_USAGE);
  else if (p[1] != '/')
    dprintf(idx, "Links to other bots must have absolute paths.\n");
  else {
    if ((p = strrchr(par, '/'))) {
      *p = 0;
      malloc_strcpy(newfn, p + 1);
      if (!resolve_dir(dcc[idx].u.file->dir, par, &newpath, idx)) {
        dprintf(idx, FILES_NOSUCHDIR);
        my_free(newfn);
        my_free(newpath);
        return;
      }
    } else {
      malloc_strcpy(newpath, dcc[idx].u.file->dir);
      malloc_strcpy(newfn, par);
    }
    fdb = filedb_open(newpath, 0);
    if (!fdb) {
      my_free(newfn);
      my_free(newpath);
      return;
    }
    filedb_readtop(fdb, NULL);
    fdbe = filedb_matchfile(fdb, ftell(fdb), newfn);
    if (fdbe) {
      if (!fdbe->sharelink) {
        dprintf(idx, FILES_NORMAL, newfn);
        filedb_close(fdb);
      } else {
        malloc_strcpy(fdbe->sharelink, share);
        filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_ALL);
        filedb_close(fdb);
        dprintf(idx, FILES_CHGLINK, share);
        putlog(LOG_FILES, "*", "files: #%s# ln %s %s",
               dcc[idx].nick, par, share);
      }
    } else {
      /* New entry */
      fdbe = malloc_fdbe();
      malloc_strcpy(fdbe->filename, newfn);
      malloc_strcpy(fdbe->uploader, dcc[idx].nick);
      fdbe->uploaded = now;
      malloc_strcpy(fdbe->sharelink, share);
      filedb_addfile(fdb, fdbe);
      filedb_close(fdb);
      dprintf(idx, "%s %s -> %s\n", FILES_ADDLINK, fdbe->filename, share);
      putlog(LOG_FILES, "*", "files: #%s# ln /%s%s%s %s", dcc[idx].nick,
             newpath, newpath[0] ? "/" : "", newfn, share);
    }
    free_fdbe(&fdbe);
    my_free(newpath);
    my_free(newfn);
  }
}

Here is the call graph for this function:

static void cmd_ls	(	int	idx,
		char *	par
	)			[static]

Definition at line 412 of file files.c.

References files_ls().

{
  files_ls(idx, par, 0);
}

Here is the call graph for this function:

static void cmd_lsa	(	int	idx,
		char *	par
	)			[static]

Definition at line 417 of file files.c.

References files_ls().

{
  files_ls(idx, par, 1);
}

Here is the call graph for this function:

static void cmd_mkdir	(	int	idx,
		char *	par
	)			[static]

Definition at line 943 of file files.c.

References break_down_flags, build_flags, filedb_entry::chan, flag_record::chan, CHANMETA, dcc, dccdir, dprintf, FILE_DIR, filedb_close(), filedb_matchfile, filedb_open(), filedb_readtop(), filedb_updatefile, filedb_entry::filename, FILES_CHGACCESS, FILES_CHGNACCESS, FILES_CREADIR, FILES_NOSUCHDIR, findchan, filedb_entry::flags_req, FR_CHAN, FR_GLOBAL, free_fdbe(), LOG_FILES, malloc_fdbe, malloc_strcpy, malloc_strcpy_nocheck, MISC_FAILED, MISC_USAGE, my_free, newsplit, nmalloc, now, NULL, filedb_entry::pos, POS_NEW, putlog, filedb_entry::stat, UPDATE_ALL, and filedb_entry::uploaded.

{
  char *name, *flags, *chan, *s;
  FILE *fdb;
  filedb_entry *fdbe;
  int ret;
  struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };

  if (!par[0]) {
    dprintf(idx, "%s: mkdir <dir> [required-flags] [channel]\n", MISC_USAGE);
    return;
  }
  name = newsplit(&par);
  ret = strlen(name);
  if (ret > 60)
    name[(ret = 60)] = 0;
  if (name[ret] == '/')
    name[ret] = 0;
  if (strchr(name, '/'))
    dprintf(idx, "You can only create directories in the current directory\n");
  else {
    flags = newsplit(&par);
    chan = newsplit(&par);
    if (!chan[0] && flags[0] && (strchr(CHANMETA, flags[0]) != NULL)) {
      /* Need some extra checking here to makesure we dont mix up
       * the flags with a +channel. <cybah>
       */
      if (!findchan(flags) && flags[0] != '+') {
        dprintf(idx, "Invalid channel!\n");
        return;
      } else if (findchan(flags)) {
        /* Flags is a channel. */
        chan = flags;
        flags = par;
      }                         /* (else) Couldn't find the channel and flags[0] is a '+', these
                                 * are flags. */
    }
    if (chan[0] && !findchan(chan)) {
      dprintf(idx, "Invalid channel!\n");
      return;
    }
    fdb = filedb_open(dcc[idx].u.file->dir, 0);
    if (!fdb)
      return;
    filedb_readtop(fdb, NULL);
    fdbe = filedb_matchfile(fdb, ftell(fdb), name);
    if (!fdbe) {
      s = nmalloc(strlen(dccdir) + strlen(dcc[idx].u.file->dir)
                  + strlen(name) + 2);
      sprintf(s, "%s%s/%s", dccdir, dcc[idx].u.file->dir, name);
      if (mkdir(s, 0755) != 0) {
        dprintf(idx, MISC_FAILED);
        filedb_close(fdb);
        my_free(s);
        return;
      }
      my_free(s);
      fdbe = malloc_fdbe();
      fdbe->stat = FILE_DIR;
      malloc_strcpy(fdbe->filename, name);
      fdbe->uploaded = now;
      dprintf(idx, "%s /%s%s%s\n", FILES_CREADIR, dcc[idx].u.file->dir,
              dcc[idx].u.file->dir[0] ? "/" : "", name);
    } else if (!(fdbe->stat & FILE_DIR)) {
      dprintf(idx, FILES_NOSUCHDIR);
      free_fdbe(&fdbe);
      filedb_close(fdb);
      return;
    }
    if (flags[0]) {
      char buffer[100];

      break_down_flags(flags, &fr, NULL);
      build_flags(buffer, &fr, NULL);
      malloc_strcpy_nocheck(fdbe->flags_req, buffer);
      dprintf(idx, FILES_CHGACCESS, name, buffer);
    } else if (!chan[0]) {
      my_free(fdbe->flags_req);
      dprintf(idx, FILES_CHGNACCESS, name);
    }
    if (chan[0]) {
      malloc_strcpy(fdbe->chan, chan);
      dprintf(idx, "Access set to channel: %s\n", chan);
    } else if (!flags[0]) {
      my_free(fdbe->chan);
      dprintf(idx, "Access set to all channels.\n");
    }
    if (!fdbe->pos)
      fdbe->pos = POS_NEW;
    filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_ALL);
    filedb_close(fdb);
    free_fdbe(&fdbe);
    putlog(LOG_FILES, "*", "files: #%s# mkdir %s %s", dcc[idx].nick, name, par);
  }
}

Here is the call graph for this function:

static void cmd_mv	(	int	idx,
		char *	par
	)			[static]

Definition at line 1294 of file files.c.

References cmd_mv_cp().

{
  cmd_mv_cp(idx, par, 0);
}

Here is the call graph for this function:

static void cmd_mv_cp	(	int	idx,
		char *	par,
		int	copy
	)			[static]

Definition at line 1098 of file files.c.

References filedb_entry::chan, copyfile, dcc, dccdir, filedb_entry::desc, dprintf, FILE_DIR, FILE_HIDDEN, filedb_addfile, filedb_close(), filedb_delfile(), filedb_matchfile, filedb_open(), filedb_readtop(), filedb_entry::filename, FILES_COPIED, FILES_COPY, FILES_ILLDEST, FILES_ILLSOURCE, FILES_MOVE, FILES_MOVED, FILES_NOMATCH, FILES_SKIPSTUPID, FILES_STUPID, filedb_entry::flags_req, free_fdbe(), filedb_entry::gots, LOG_FILES, malloc_fdbe, malloc_strcpy, MISC_USAGE, movefile, my_free, newsplit, nmalloc, NULL, filedb_entry::pos, putlog, resolve_dir(), filedb_entry::sharelink, filedb_entry::size, filedb_entry::stat, filedb_entry::uploaded, and filedb_entry::uploader.

Referenced by cmd_cp(), and cmd_mv().

{
  char *p, *fn, *oldpath = NULL, *s = NULL, *s1, *newfn = NULL;
  char *newpath = NULL;
  int ok = 0, only_first = 0, skip_this = 0;
  FILE *fdb_old = NULL, *fdb_new = NULL;
  filedb_entry *fdbe_old = NULL, *fdbe_new = NULL;
  long where = 0;

  fn = newsplit(&par);
  if (!par[0]) {
    dprintf(idx, "%s: %s <oldfilepath> <newfilepath>\n",
            MISC_USAGE, copy ? "cp" : "mv");
    return;
  }
  p = strrchr(fn, '/');
  if (p != NULL) {
    *p = 0;
    malloc_strcpy(s, fn);
    strcpy(fn, p + 1);
    if (!resolve_dir(dcc[idx].u.file->dir, s, &oldpath, idx)) {
      dprintf(idx, FILES_ILLSOURCE);
      my_free(s);
      my_free(oldpath);
      return;
    }
    my_free(s);
  } else
    malloc_strcpy(oldpath, dcc[idx].u.file->dir);
  malloc_strcpy(s, par);
  if (!resolve_dir(dcc[idx].u.file->dir, s, &newpath, idx)) {
    my_free(newpath);
    /* Destination is not just a directory */
    p = strrchr(s, '/');
    if (p == NULL) {
      malloc_strcpy(newfn, s);
      s[0] = 0;
    } else {
      *p = 0;
      malloc_strcpy(newfn, p + 1);
    }
    if (!resolve_dir(dcc[idx].u.file->dir, s, &newpath, idx)) {
      dprintf(idx, FILES_ILLDEST);
      my_free(newfn);
      my_free(s);
      my_free(oldpath);
      my_free(newpath);
      return;
    }
  } else
    malloc_strcpy(newfn, "");
  my_free(s);
  /* Stupidness checks */
  if ((!strcmp(oldpath, newpath)) && ((!newfn[0]) || (!strcmp(newfn, fn)))) {
    dprintf(idx, FILES_STUPID, copy ? FILES_COPY : FILES_MOVE);
    my_free(oldpath);
    my_free(newpath);
    my_free(newfn);
    return;
  }
  /* Be aware of 'cp * this.file' possibility: ONLY COPY FIRST ONE */
  if ((strchr(fn, '?') || strchr(fn, '*')) && newfn[0])
    only_first = 1;
  else
    only_first = 0;

  fdb_old = filedb_open(oldpath, 0);
  if (!strcmp(oldpath, newpath))
    fdb_new = fdb_old;
  else
    fdb_new = filedb_open(newpath, 0);
  if (!fdb_old || !fdb_new) {
    my_free(oldpath);
    my_free(newpath);
    my_free(newfn);
    return;
  }

  filedb_readtop(fdb_old, NULL);
  where = ftell(fdb_old);
  fdbe_old = filedb_matchfile(fdb_old, where, fn);
  if (!fdbe_old) {
    if (fdb_new != fdb_old)
      filedb_close(fdb_new);
    filedb_close(fdb_old);
    my_free(oldpath);
    my_free(newpath);
    my_free(newfn);
    return;
  }

  if (only_first) {
    /* If the source file contains a wildcard and the dest is not a dir,
     * then we check for multiple source files and if they are there,
     * abort. Otherwise, proceed. */
    filedb_entry *check_for_more;
    check_for_more = filedb_matchfile(fdb_old, ftell(fdb_old), fn);
    if (check_for_more) {
      dprintf(idx, FILES_ILLDEST);
      free_fdbe(&fdbe_old);
      free_fdbe(&check_for_more);
      if (fdb_new != fdb_old) filedb_close(fdb_new);
      filedb_close(fdb_old);
      my_free(oldpath);
      my_free(newpath);
      my_free(newfn);
      return;
    }
    fseek(fdb_old, where, SEEK_SET);
  }

  while (fdbe_old) {
    where = ftell(fdb_old);
    skip_this = 0;
    if (!(fdbe_old->stat & (FILE_HIDDEN | FILE_DIR))) {
      s = nmalloc(strlen(dccdir) + strlen(oldpath)
                  + strlen(fdbe_old->filename) + 2);
      s1 = nmalloc(strlen(dccdir) + strlen(newpath)
                   + strlen(newfn[0] ? newfn : fdbe_old->filename) + 2);
      sprintf(s, "%s%s%s%s", dccdir, oldpath,
              oldpath[0] ? "/" : "", fdbe_old->filename);
      sprintf(s1, "%s%s%s%s", dccdir, newpath,
              newpath[0] ? "/" : "", newfn[0] ? newfn : fdbe_old->filename);
      if (!strcmp(s, s1)) {
        dprintf(idx, "%s /%s%s%s %s\n", FILES_SKIPSTUPID,
                copy ? FILES_COPY : FILES_MOVE, newpath,
                newpath[0] ? "/" : "", newfn[0] ? newfn : fdbe_old->filename);
        skip_this = 1;
      }
      /* Check for existence of file with same name in new dir */
      filedb_readtop(fdb_new, NULL);
      fdbe_new = filedb_matchfile(fdb_new, ftell(fdb_new),
                                  newfn[0] ? newfn : fdbe_old->filename);
      if (fdbe_new) {
        /* It's ok if the entry in the new dir is a normal file (we'll
         * just scrap the old entry and overwrite the file) -- but if
         * it's a directory, this file has to be skipped.
         */
        if (fdbe_new->stat & FILE_DIR)
          skip_this = 1;
        else
          filedb_delfile(fdb_new, fdbe_new->pos);
        free_fdbe(&fdbe_new);
      }
      if (!skip_this) {
        if ((fdbe_old->sharelink) ||
            ((copy ? copyfile(s, s1) : movefile(s, s1)) == 0)) {
          /* Raw file moved okay: create new entry for it */
          ok++;
          fdbe_new = malloc_fdbe();
          fdbe_new->stat = fdbe_old->stat;
          /* We don't have to worry about any entries to be
           * NULL, because malloc_strcpy takes care of that.
           */
          malloc_strcpy(fdbe_new->flags_req, fdbe_old->flags_req);
          malloc_strcpy(fdbe_new->chan, fdbe_old->chan);
          malloc_strcpy(fdbe_new->filename, fdbe_old->filename);
          malloc_strcpy(fdbe_new->desc, fdbe_old->desc);
          if (newfn[0])
            malloc_strcpy(fdbe_new->filename, newfn);
          malloc_strcpy(fdbe_new->uploader, fdbe_old->uploader);
          fdbe_new->uploaded = fdbe_old->uploaded;
          fdbe_new->size = fdbe_old->size;
          fdbe_new->gots = fdbe_old->gots;
          malloc_strcpy(fdbe_new->sharelink, fdbe_old->sharelink);
          filedb_addfile(fdb_new, fdbe_new);
          if (!copy)
            filedb_delfile(fdb_old, fdbe_old->pos);
          free_fdbe(&fdbe_new);
        }
      }
      my_free(s);
      my_free(s1);
    }
    free_fdbe(&fdbe_old);
    fdbe_old = filedb_matchfile(fdb_old, where, fn);
    if (ok && only_first)
      free_fdbe(&fdbe_old);
  }
  if (fdb_old != fdb_new)
    filedb_close(fdb_new);
  filedb_close(fdb_old);
  if (!ok)
    dprintf(idx, FILES_NOMATCH);
  else {
    putlog(LOG_FILES, "*", "files: #%s# %s %s%s%s %s", dcc[idx].nick,
           copy ? "cp" : "mv", oldpath, oldpath[0] ? "/" : "", fn, par);
    if (ok > 1)
      dprintf(idx, "%s %d file%s.\n",
              copy ? FILES_COPIED : FILES_MOVED, ok, ok == 1 ? "" : "s");
  }
  my_free(oldpath);
  my_free(newpath);
  my_free(newfn);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cmd_optimize	(	int	idx,
		char *	par
	)			[static]

Definition at line 118 of file files.c.

References dcc, dprintf, filedb_close(), filedb_open(), FILES_ILLDIR, get_user, get_user_by_handle, LOG_FILES, NULL, putlog, set_user, USERENTRY_DCCDIR, and userlist.

{
  struct userrec *u = get_user_by_handle(userlist, dcc[idx].nick);
  FILE *fdb = NULL;
  char *p = NULL;

  putlog(LOG_FILES, "*", "files: #%s# optimize", dcc[idx].nick);
  p = get_user(&USERENTRY_DCCDIR, u);
  /* Does this dir even exist any more? */
  if (p) {
    fdb = filedb_open(p, 1);
    if (!fdb) {
      set_user(&USERENTRY_DCCDIR, u, NULL);
      p = NULL;
    }
  }
  if (!p)
    fdb = filedb_open("", 1);
  if (!fdb) {
    dprintf(idx, FILES_ILLDIR);
    return;
  }
  filedb_close(fdb);
  dprintf(idx, "Current directory is now optimized.\n");
}

Here is the call graph for this function:

static void cmd_pending	(	int	idx,
		char *	par
	)			[static]

Definition at line 321 of file files.c.

References dcc, LOG_FILES, putlog, and show_queued_files().

{
  show_queued_files(idx);
  putlog(LOG_FILES, "*", "files: #%s# pending", dcc[idx].nick);
}

Here is the call graph for this function:

static void cmd_pwd	(	int	idx,
		char *	par
	)			[static]

Definition at line 315 of file files.c.

References dcc, dprintf, FILES_CURDIR, LOG_FILES, and putlog.

{
  putlog(LOG_FILES, "*", "files: #%s# pwd", dcc[idx].nick);
  dprintf(idx, "%s: /%s\n", FILES_CURDIR, dcc[idx].u.file->dir);
}

static void cmd_reget	(	int	idx,
		char *	par
	)			[static]

Definition at line 524 of file files.c.

References cmd_reget_get().

{
  cmd_reget_get(idx, par, 1);
}

Here is the call graph for this function:

static void cmd_reget_get	(	int	idx,
		char *	par,
		int	resend
	)			[static]

Definition at line 422 of file files.c.

References flag_record::bot, botnet_send_filereq, botnetnick, dcc, do_dcc_send(), dprintf, egg_strcasecmp, FILE_DIR, FILE_HIDDEN, filedb_close(), filedb_matchfile, filedb_open(), filedb_readtop(), filedb_updatefile, filedb_entry::filename, FILES_BADNICK, FILES_ILLDIR, FILES_NOMATCH, FILES_NOTAVAIL, FILES_REQUESTED, free_fdbe(), _module_entry::funcs, filedb_entry::gots, in_chain, LOG_FILES, malloc_strcpy, MISC_USAGE, module_find, my_free, newsplit, nextbot, NICKLEN, nmalloc, nrealloc, NULL, filedb_entry::pos, putlog, resolve_dir(), SERVER_NICKLEN, filedb_entry::sharelink, simple_sprintf, splitc, filedb_entry::stat, and UPDATE_ALL.

Referenced by cmd_get(), and cmd_reget().

{
  int ok = 0, i;
  char *p, *what, *destdir = NULL, *s = NULL;
  filedb_entry *fdbe;
  FILE *fdb;
  long where = 0;
  int nicklen = NICKLEN;

  /* Get the nick length if necessary. */
  if (NICKLEN > 9) {
    module_entry *me = module_find("server", 1, 1);

    if (me && me->funcs)
      nicklen = (*(int *)me->funcs[SERVER_NICKLEN]);
  }
  if (!par[0]) {
    dprintf(idx, "%s: %sget <file(s)> [nickname]\n", MISC_USAGE,
            resend ? "re" : "");
    return;
  }
  what = newsplit(&par);
  if (strlen(par) > nicklen) {
    dprintf(idx, FILES_BADNICK);
    return;
  }
  p = strrchr(what, '/');
  if (p != NULL) {
    *p = 0;
    malloc_strcpy(s, what);
    strcpy(what, p + 1);
    if (!resolve_dir(dcc[idx].u.file->dir, s, &destdir, idx)) {
      my_free(destdir);
      my_free(s);
      dprintf(idx, FILES_ILLDIR);
      return;
    }
    my_free(s);
  } else
    malloc_strcpy(destdir, dcc[idx].u.file->dir);
  fdb = filedb_open(destdir, 0);
  if (!fdb)
    return;
  filedb_readtop(fdb, NULL);
  fdbe = filedb_matchfile(fdb, ftell(fdb), what);
  if (!fdbe) {
    filedb_close(fdb);
    free_fdbe(&fdbe);
    my_free(destdir);
    dprintf(idx, FILES_NOMATCH);
    return;
  }
  while (fdbe) {
    where = ftell(fdb);
    if (!(fdbe->stat & (FILE_HIDDEN | FILE_DIR))) {
      ok = 1;
      if (fdbe->sharelink) {
        char *bot, *whoto = NULL;

        /* This is a link to a file on another bot... */
        bot = nmalloc(strlen(fdbe->sharelink) + 1);
        splitc(bot, fdbe->sharelink, ':');
        if (!egg_strcasecmp(bot, botnetnick))
          dprintf(idx, "Can't get that file, it's linked to this bot!\n");
        else if (!in_chain(bot))
          dprintf(idx, FILES_NOTAVAIL, fdbe->filename);
        else {
          i = nextbot(bot);
          malloc_strcpy(whoto, par);
          if (!whoto[0])
            malloc_strcpy(whoto, dcc[idx].nick);
          s = nmalloc(strlen(whoto) + strlen(botnetnick) + 13);
          simple_sprintf(s, "%d:%s@%s", dcc[idx].sock, whoto, botnetnick);
          botnet_send_filereq(i, s, bot, fdbe->sharelink);
          dprintf(idx, FILES_REQUESTED, fdbe->sharelink, bot);
          /* Increase got count now (or never) */
          fdbe->gots++;
          s = nrealloc(s, strlen(bot) + strlen(fdbe->sharelink) + 2);
          sprintf(s, "%s:%s", bot, fdbe->sharelink);
          malloc_strcpy(fdbe->sharelink, s);
          filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_ALL);
          my_free(whoto);
          my_free(s);
        }
        my_free(bot);
      } else {
        do_dcc_send(idx, destdir, fdbe->filename, par, resend);
        /* Don't increase got count till later */
      }
    }
    free_fdbe(&fdbe);
    fdbe = filedb_matchfile(fdb, where, what);
  }
  filedb_close(fdb);
  my_free(destdir);
  if (!ok)
    dprintf(idx, FILES_NOMATCH);
  else
    putlog(LOG_FILES, "*", "files: #%s# %sget %s %s", dcc[idx].nick,
           resend ? "re" : "", what, par);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cmd_rm	(	int	idx,
		char *	par
	)			[static]

Definition at line 894 of file files.c.

References dcc, dccdir, dprintf, FILE_DIR, FILE_HIDDEN, filedb_close(), filedb_delfile(), filedb_matchfile, filedb_open(), filedb_readtop(), filedb_entry::filename, FILES_ERASED, FILES_NOMATCH, free_fdbe(), LOG_FILES, MISC_USAGE, my_free, nmalloc, NULL, filedb_entry::pos, putlog, filedb_entry::sharelink, and filedb_entry::stat.

{
  FILE *fdb;
  filedb_entry *fdbe;
  long where;
  int ok = 0;
  char *s;

  if (!par[0]) {
    dprintf(idx, "%s: rm <file(s)>\n", MISC_USAGE);
    return;
  }
  fdb = filedb_open(dcc[idx].u.file->dir, 0);
  if (!fdb)
    return;
  filedb_readtop(fdb, NULL);
  fdbe = filedb_matchfile(fdb, ftell(fdb), par);
  if (!fdbe) {
    filedb_close(fdb);
    dprintf(idx, FILES_NOMATCH);
    return;
  }
  while (fdbe) {
    where = ftell(fdb);
    if (!(fdbe->stat & (FILE_HIDDEN | FILE_DIR))) {
      s = nmalloc(strlen(dccdir) + strlen(dcc[idx].u.file->dir)
                  + strlen(fdbe->filename) + 2);
      sprintf(s, "%s%s/%s", dccdir, dcc[idx].u.file->dir, fdbe->filename);
      ok++;
      filedb_delfile(fdb, fdbe->pos);
      /* Shared file links won't be able to be unlinked */
      if (!(fdbe->sharelink))
        unlink(s);
      dprintf(idx, "%s: %s\n", FILES_ERASED, fdbe->filename);
      my_free(s);
    }
    free_fdbe(&fdbe);
    fdbe = filedb_matchfile(fdb, where, par);
  }
  filedb_close(fdb);
  if (!ok)
    dprintf(idx, FILES_NOMATCH);
  else {
    putlog(LOG_FILES, "*", "files: #%s# rm %s", dcc[idx].nick, par);
    if (ok > 1)
      dprintf(idx, "%s %d file%s.\n", FILES_ERASED, ok, ok == 1 ? "" : "s");
  }
}

Here is the call graph for this function:

static void cmd_rmdir	(	int	idx,
		char *	par
	)			[static]

Definition at line 1039 of file files.c.

References dcc, dccdir, dprintf, FILE_DIR, filedb_close(), filedb_delfile(), filedb_matchfile, filedb_open(), filedb_readtop(), FILES_NOSUCHDIR, FILES_REMDIR, free_fdbe(), LOG_FILES, malloc_strcpy, MISC_FAILED, my_free, nmalloc, NULL, filedb_entry::pos, putlog, and filedb_entry::stat.

{
  FILE *fdb;
  filedb_entry *fdbe;
  char *s, *name = NULL;

  malloc_strcpy(name, par);
  if (name[strlen(name) - 1] == '/')
    name[strlen(name) - 1] = 0;
  if (strchr(name, '/'))
    dprintf(idx, "You can only create directories in the current directory\n");
  else {
    fdb = filedb_open(dcc[idx].u.file->dir, 0);
    if (!fdb) {
      my_free(name);
      return;
    }
    filedb_readtop(fdb, NULL);
    fdbe = filedb_matchfile(fdb, ftell(fdb), name);
    if (!fdbe) {
      dprintf(idx, FILES_NOSUCHDIR);
      filedb_close(fdb);
      my_free(name);
      return;
    }
    if (!(fdbe->stat & FILE_DIR)) {
      dprintf(idx, FILES_NOSUCHDIR);
      filedb_close(fdb);
      my_free(name);
      free_fdbe(&fdbe);
      return;
    }
    /* Erase '.filedb' and '.files' if they exist */
    s = nmalloc(strlen(dccdir) + strlen(dcc[idx].u.file->dir)
                + strlen(name) + 10);
    sprintf(s, "%s%s/%s/.filedb", dccdir, dcc[idx].u.file->dir, name);
    unlink(s);
    sprintf(s, "%s%s/%s/.files", dccdir, dcc[idx].u.file->dir, name);
    unlink(s);
    sprintf(s, "%s%s/%s", dccdir, dcc[idx].u.file->dir, name);
    if (rmdir(s) == 0) {
      dprintf(idx, "%s /%s%s%s\n", FILES_REMDIR, dcc[idx].u.file->dir,
              dcc[idx].u.file->dir[0] ? "/" : "", name);
      filedb_delfile(fdb, fdbe->pos);
      filedb_close(fdb);
      free_fdbe(&fdbe);
      my_free(s);
      my_free(name);
      putlog(LOG_FILES, "*", "files: #%s# rmdir %s", dcc[idx].nick, name);
      return;
    }
    dprintf(idx, MISC_FAILED);
    filedb_close(fdb);
    free_fdbe(&fdbe);
    my_free(s);
    my_free(name);
  }
}

Here is the call graph for this function:

static void cmd_share	(	int	idx,
		char *	par
	)			[static]

Definition at line 637 of file files.c.

References dcc, dprintf, FILE_DIR, FILE_HIDDEN, FILE_SHARE, filedb_close(), filedb_matchfile, filedb_open(), filedb_readtop(), filedb_updatefile, filedb_entry::filename, FILES_NOMATCH, FILES_SHARED, free_fdbe(), LOG_FILES, MISC_USAGE, NULL, filedb_entry::pos, putlog, filedb_entry::stat, and UPDATE_HEADER.

{
  FILE *fdb;
  filedb_entry *fdbe;
  long where;
  int ok = 0;

  if (!par[0]) {
    dprintf(idx, "%s: share <file(s)>\n", MISC_USAGE);
    return;
  }
  fdb = filedb_open(dcc[idx].u.file->dir, 0);
  if (!fdb)
    return;
  filedb_readtop(fdb, NULL);
  fdbe = filedb_matchfile(fdb, ftell(fdb), par);
  if (!fdbe) {
    filedb_close(fdb);
    dprintf(idx, FILES_NOMATCH);
    return;
  }
  while (fdbe) {
    where = ftell(fdb);
    if (!(fdbe->stat & (FILE_HIDDEN | FILE_DIR | FILE_SHARE))) {
      fdbe->stat |= FILE_SHARE;
      ok++;
      dprintf(idx, "%s: %s\n", FILES_SHARED, fdbe->filename);
      filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_HEADER);
    }
    free_fdbe(&fdbe);
    fdbe = filedb_matchfile(fdb, where, par);
  }
  filedb_close(fdb);
  if (!ok)
    dprintf(idx, FILES_NOMATCH);
  else {
    putlog(LOG_FILES, "*", "files: #%s# share %s", dcc[idx].nick, par);
    if (ok > 1)
      dprintf(idx, "%s %d file%s.\n", FILES_SHARED, ok, ok == 1 ? "" : "s");
  }
}

Here is the call graph for this function:

static int cmd_stats	(	int	idx,
		char *	par
	)			[static]

Definition at line 1304 of file files.c.

References dcc, LOG_FILES, putlog, and tell_file_stats().

{
  putlog(LOG_FILES, "*", "#%s# stats", dcc[idx].nick);
  tell_file_stats(idx, dcc[idx].nick);
  return 0;
}

Here is the call graph for this function:

static void cmd_unhide	(	int	idx,
		char *	par
	)			[static]

Definition at line 595 of file files.c.

References dcc, dprintf, FILE_HIDDEN, filedb_close(), filedb_matchfile, filedb_open(), filedb_readtop(), filedb_updatefile, filedb_entry::filename, FILES_NOMATCH, FILES_UNHID, free_fdbe(), LOG_FILES, MISC_USAGE, NULL, filedb_entry::pos, putlog, filedb_entry::stat, and UPDATE_HEADER.

{
  FILE *fdb;
  filedb_entry *fdbe;
  long where;
  int ok = 0;

  if (!par[0]) {
    dprintf(idx, "%s: unhide <file(s)>\n", MISC_USAGE);
    return;
  }
  fdb = filedb_open(dcc[idx].u.file->dir, 0);
  if (!fdb)
    return;
  filedb_readtop(fdb, NULL);
  fdbe = filedb_matchfile(fdb, ftell(fdb), par);
  if (!fdbe) {
    filedb_close(fdb);
    dprintf(idx, FILES_NOMATCH);
    return;
  }
  while (fdbe) {
    where = ftell(fdb);
    if (fdbe->stat & FILE_HIDDEN) {
      fdbe->stat &= ~FILE_HIDDEN;
      ok++;
      dprintf(idx, "%s: %s\n", FILES_UNHID, fdbe->filename);
      filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_HEADER);
    }
    free_fdbe(&fdbe);
    fdbe = filedb_matchfile(fdb, where, par);
  }
  filedb_close(fdb);
  if (!ok)
    dprintf(idx, FILES_NOMATCH);
  else {
    putlog(LOG_FILES, "*", "files: #%s# unhide %s", dcc[idx].nick, par);
    if (ok > 1)
      dprintf(idx, "%s %d file%s.\n", FILES_UNHID, ok, ok == 1 ? "" : "s");
  }
}

Here is the call graph for this function:

static void cmd_unshare	(	int	idx,
		char *	par
	)			[static]

Definition at line 679 of file files.c.

References dcc, dprintf, FILE_DIR, FILE_HIDDEN, FILE_SHARE, filedb_close(), filedb_matchfile, filedb_open(), filedb_readtop(), filedb_updatefile, filedb_entry::filename, FILES_NOMATCH, FILES_UNSHARED, free_fdbe(), LOG_FILES, MISC_USAGE, NULL, filedb_entry::pos, putlog, filedb_entry::stat, and UPDATE_HEADER.

{
  FILE *fdb;
  filedb_entry *fdbe;
  long where;
  int ok = 0;

  if (!par[0]) {
    dprintf(idx, "%s: unshare <file(s)>\n", MISC_USAGE);
    return;
  }
  fdb = filedb_open(dcc[idx].u.file->dir, 0);
  if (!fdb)
    return;
  filedb_readtop(fdb, NULL);
  fdbe = filedb_matchfile(fdb, ftell(fdb), par);
  if (!fdbe) {
    filedb_close(fdb);
    dprintf(idx, FILES_NOMATCH);
    return;
  }
  while (fdbe) {
    where = ftell(fdb);
    if ((fdbe->stat & FILE_SHARE) &&
        !(fdbe->stat & (FILE_DIR | FILE_HIDDEN))) {
      fdbe->stat &= ~FILE_SHARE;
      ok++;
      dprintf(idx, "%s: %s\n", FILES_UNSHARED, fdbe->filename);
      filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_HEADER);
    }
    free_fdbe(&fdbe);
    fdbe = filedb_matchfile(fdb, where, par);
  }
  filedb_close(fdb);
  if (!ok)
    dprintf(idx, FILES_NOMATCH);
  else {
    putlog(LOG_FILES, "*", "files: #%s# unshare %s", dcc[idx].nick, par);
    if (ok > 1)
      dprintf(idx, "%s %d file%s.\n", FILES_UNSHARED, ok, ok == 1 ? "" : "s");
  }
}

Here is the call graph for this function:

static void files_ls	(	int	idx,
		char *	par,
		int	showall
	)			[static]

Definition at line 359 of file files.c.

References dcc, dprintf, filedb_close(), filedb_ls(), filedb_open(), FILES_ILLDIR, LOG_FILES, malloc_strcpy, my_free, NULL, putlog, and resolve_dir().

Referenced by cmd_ls(), and cmd_lsa().

{
  char *p, *s = NULL, *destdir = NULL, *mask = NULL;
  FILE *fdb;

  if (par[0]) {
    putlog(LOG_FILES, "*", "files: #%s# ls %s", dcc[idx].nick, par);
    p = strrchr(par, '/');
    if (p != NULL) {
      *p = 0;
      malloc_strcpy(s, par);
      malloc_strcpy(mask, p + 1);
      if (!resolve_dir(dcc[idx].u.file->dir, s, &destdir, idx)) {
        dprintf(idx, FILES_ILLDIR);
        my_free(s);
        my_free(mask);
        my_free(destdir);
        return;
      }
      my_free(s);
    } else {
      malloc_strcpy(destdir, dcc[idx].u.file->dir);
      malloc_strcpy(mask, par);
    }
    /* Might be 'ls dir'? */
    if (resolve_dir(destdir, mask, &s, idx)) {
      /* Aha! it was! */
      malloc_strcpy(destdir, s);
      malloc_strcpy(mask, "*");
    }
    my_free(s);
    fdb = filedb_open(destdir, 0);
    if (!fdb) {
      dprintf(idx, FILES_ILLDIR);
      my_free(destdir);
      my_free(mask);
      return;
    }
    filedb_ls(fdb, idx, mask, showall);
    filedb_close(fdb);
    my_free(destdir);
    my_free(mask);
  } else {
    putlog(LOG_FILES, "*", "files: #%s# ls", dcc[idx].nick);
    fdb = filedb_open(dcc[idx].u.file->dir, 0);
    if (fdb) {
      filedb_ls(fdb, idx, "*", showall);
      filedb_close(fdb);
    } else
      dprintf(idx, FILES_ILLDIR);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int files_reget	(	int	idx,
		char *	fn,
		char *	nick,
		int	resend
	)			[static]

Definition at line 1391 of file files.c.

References botnet_send_filereq, botnetnick, dcc, do_dcc_send(), dprintf, egg_strcasecmp, FILE_DIR, FILE_HIDDEN, filedb_close(), filedb_matchfile, filedb_open(), filedb_readtop(), filedb_updatefile, filedb_entry::filename, FILES_REQUESTED, free_fdbe(), filedb_entry::gots, in_chain, malloc_strcpy, my_free, nextbot, nmalloc, nrealloc, NULL, filedb_entry::pos, resolve_dir(), filedb_entry::sharelink, simple_sprintf, splitc, filedb_entry::stat, and UPDATE_ALL.

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

  p = strrchr(fn, '/');
  if (p != NULL) {
    *p = 0;
    malloc_strcpy(s, fn);
    malloc_strcpy(what, p + 1);
    if (!resolve_dir(dcc[idx].u.file->dir, s, &destdir, idx)) {
      my_free(s);
      my_free(what);
      my_free(destdir);
      return 0;
    }
    my_free(s);
  } else {
    malloc_strcpy(destdir, dcc[idx].u.file->dir);
    malloc_strcpy(what, fn);
  }
  fdb = filedb_open(destdir, 0);
  if (!fdb) {
    my_free(what);
    my_free(destdir);
    return 0;
  }
  filedb_readtop(fdb, NULL);
  fdbe = filedb_matchfile(fdb, ftell(fdb), what);
  if (!fdbe) {
    filedb_close(fdb);
    my_free(what);
    my_free(destdir);
    return 0;
  }
  if (fdbe->stat & (FILE_HIDDEN | FILE_DIR)) {
    filedb_close(fdb);
    my_free(what);
    my_free(destdir);
    free_fdbe(&fdbe);
    return 0;
  }
  if (fdbe->sharelink) {
    char *bot, *whoto = NULL;

    /* This is a link to a file on another bot... */
    bot = nmalloc(strlen(fdbe->sharelink) + 1);
    splitc(bot, fdbe->sharelink, ':');
    if (!egg_strcasecmp(bot, botnetnick)) {
      /* Linked to myself *duh* */
      filedb_close(fdb);
      my_free(what);
      my_free(destdir);
      my_free(bot);
      free_fdbe(&fdbe);
      return 0;
    } else if (!in_chain(bot)) {
      filedb_close(fdb);
      my_free(what);
      my_free(destdir);
      my_free(bot);
      free_fdbe(&fdbe);
      return 0;
    } else {
      i = nextbot(bot);
      if (nick[0]) {
        malloc_strcpy(whoto, nick);
      } else {
        malloc_strcpy(whoto, dcc[idx].nick);
      }
      s = nmalloc(strlen(whoto) + strlen(botnetnick) + 13);
      simple_sprintf(s, "%d:%s@%s", dcc[idx].sock, whoto, botnetnick);
      botnet_send_filereq(i, s, bot, fdbe->sharelink);
      dprintf(idx, FILES_REQUESTED, fdbe->sharelink, bot);
      /* Increase got count now (or never) */
      fdbe->gots++;
      s = nrealloc(s, strlen(bot) + strlen(fdbe->sharelink) + 2);
      sprintf(s, "%s:%s", bot, fdbe->sharelink);
      malloc_strcpy(fdbe->sharelink, s);
      filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_ALL);
      filedb_close(fdb);
      free_fdbe(&fdbe);
      my_free(what);
      my_free(destdir);
      my_free(bot);
      my_free(whoto);
      my_free(s);
      return 1;
    }
  }
  filedb_close(fdb);
  do_dcc_send(idx, destdir, fdbe->filename, nick, resend);
  my_free(what);
  my_free(destdir);
  free_fdbe(&fdbe);
  /* Don't increase got count till later */
  return 1;
}

Here is the call graph for this function:

static void files_setpwd	(	int	idx,
		char *	where
	)			[static]

Definition at line 1492 of file files.c.

References dcc, get_user_by_handle, my_free, resolve_dir(), set_user, USERENTRY_DCCDIR, and userlist.

{
  char *s;

  if (!resolve_dir(dcc[idx].u.file->dir, where, &s, idx))
    return;
  strcpy(dcc[idx].u.file->dir, s);
  set_user(&USERENTRY_DCCDIR, get_user_by_handle(userlist, dcc[idx].nick),
           dcc[idx].u.file->dir);
  my_free(s);
}

Here is the call graph for this function:

static void filesys_note	(	int	idx,
		char *	par
	)			[static]

Definition at line 1338 of file files.c.

References dcc, dprintf, _module_entry::funcs, get_user_by_handle, module_find, NOTES_CMD_NOTE, and userlist.

{
  struct userrec *u = get_user_by_handle(userlist, dcc[idx].nick);
  module_entry *me = module_find("notes", 2, 1);

  if (me && me->funcs) {
    Function f = me->funcs[NOTES_CMD_NOTE];

    (f) (u, idx, par);
  } else
    dprintf(idx, "Sending of notes is not supported.\n");
}

static void incr_file_gots

(

char *

ppath

)

[static]

Definition at line 271 of file files.c.

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

{
  char *p, *path = NULL, *destdir = NULL, *fn = NULL;
  filedb_entry *fdbe;
  FILE *fdb;

  /* Absolute dir?  probably a tcl script sending it, and it might not
   * be in the file system at all, so just leave it alone.
   */
  if ((ppath[0] == '*') || (ppath[0] == '/'))
    return;
  malloc_strcpy(path, ppath);
  p = strrchr(path, '/');
  if (p != NULL) {
    *p = 0;
    malloc_strcpy(destdir, path);
    malloc_strcpy(fn, p + 1);
    *p = '/';
  } else {
    malloc_strcpy(destdir, "");
    malloc_strcpy(fn, path);
  }
  fdb = filedb_open(destdir, 0);
  if (!fdb) {
    my_free(path);
    my_free(destdir);
    my_free(fn);
    return;                     /* Not my concern, then */
  }
  my_free(path);
  my_free(destdir);
  filedb_readtop(fdb, NULL);
  fdbe = filedb_matchfile(fdb, ftell(fdb), fn);
  my_free(fn);
  if (fdbe) {
    fdbe->gots++;
    filedb_updatefile(fdb, fdbe->pos, fdbe, UPDATE_HEADER);
    free_fdbe(&fdbe);
  }
  filedb_close(fdb);
}

Here is the call graph for this function:

static int resolve_dir	(	char *	current,
		char *	change,
		char **	real,
		int	idx
	)			[static]

Definition at line 149 of file files.c.

References break_down_flags, filedb_entry::chan, dcc, dccdir, FILE_DIR, filedb_close(), filedb_matchfile, filedb_open(), filedb_readtop(), flagrec_ok, filedb_entry::flags_req, FR_CHAN, FR_GLOBAL, free_fdbe(), get_user_flagrec, malloc_strcpy, my_free, nmalloc, nrealloc, NULL, filedb_entry::sharelink, filedb_entry::stat, USER_BOT, USER_FRIEND, USER_MASTER, USER_OP, and USER_OWNER.

Referenced by cmd_chdir(), cmd_ln(), cmd_mv_cp(), cmd_reget_get(), files_ls(), files_reget(), and files_setpwd().

{
  char *elem = NULL, *s = NULL, *new = NULL, *work = NULL, *p = NULL;
  FILE *fdb = NULL;
  DIR *dir = NULL;
  filedb_entry *fdbe = NULL;
  struct flag_record user = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 },
                     req = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };

  *real = NULL;
  malloc_strcpy(*real, current);
  if (!change[0])
    return 1;                   /* No change? */
  new = nmalloc(strlen(change) + 2);    /* Add 2, because we add '/' below */
  strcpy(new, change);
  if (new[0] == '/') {
    /* EVERYONE has access here */
    (*real)[0] = 0;
    strcpy(new, &new[1]);
  }
  /* Cycle thru the elements */
  strcat(new, "/");
  p = strchr(new, '/');
  while (p) {
    *p = 0;
    p++;
    malloc_strcpy(elem, new);
    strcpy(new, p);
    if (!elem[0] || !strcmp(elem, ".")) {
      p = strchr(new, '/');
      continue;
    } else if (!strcmp(elem, "..")) {
      /* Always allowed */
      p = strrchr(*real, '/');
      if (p == NULL) {
        /* Can't go back from here? */
        if (!(*real)[0]) {
          my_free(elem);
          my_free(new);
          malloc_strcpy(*real, current);
          return 0;
        }
        (*real)[0] = 0;
      } else
        *p = 0;
    } else {
      /* Allowed access here? */
      fdb = filedb_open(*real, 0);
      if (!fdb) {
        /* Non-existent starting point! */
        my_free(elem);
        my_free(new);
        malloc_strcpy(*real, current);
        return 0;
      }
      filedb_readtop(fdb, NULL);
      fdbe = filedb_matchfile(fdb, ftell(fdb), elem);
      filedb_close(fdb);
      if (!fdbe) {
        /* Non-existent */
        my_free(elem);
        my_free(new);
        my_free(s);
        malloc_strcpy(*real, current);
        return 0;
      }
      if (!(fdbe->stat & FILE_DIR) || fdbe->sharelink) {
        /* Not a dir */
        free_fdbe(&fdbe);
        my_free(elem);
        my_free(new);
        my_free(s);
        malloc_strcpy(*real, current);
        return 0;
      }
      if (idx >= 0)
        get_user_flagrec(dcc[idx].user, &user, fdbe->chan);
      else
        user.global = USER_OWNER | USER_BOT | USER_MASTER | USER_OP |
                      USER_FRIEND;

      if (fdbe->flags_req) {
        break_down_flags(fdbe->flags_req, &req, NULL);
        if (!flagrec_ok(&req, &user)) {
          free_fdbe(&fdbe);
          my_free(elem);
          my_free(new);
          my_free(s);
          malloc_strcpy(*real, current);
          return 0;
        }
      }
      free_fdbe(&fdbe);
      malloc_strcpy(s, *real);
      if (s[0] && s[strlen(s) - 1] != '/') {
          s = nrealloc(s, strlen(s) + 2);
          strcat(s, "/");
      }
      work = nmalloc(strlen(s) + strlen(elem) + 1);
      sprintf(work, "%s%s", s, elem);
      malloc_strcpy(*real, work);
      s = nrealloc(s, strlen(dccdir) + strlen(*real) + 1);
      sprintf(s, "%s%s", dccdir, *real);
    }
    p = strchr(new, '/');
  }
  my_free(new);
  if (elem)
    my_free(elem);
  if (work)
    my_free(work);
  /* Sanity check: does this dir exist? */
  s = nrealloc(s, strlen(dccdir) + strlen(*real) + 1);
  sprintf(s, "%s%s", dccdir, *real);
  dir = opendir(s);
  my_free(s);
  if (!dir)
    return 0;
  closedir(dir);
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int too_many_filers

(

)

[static]

Definition at line 48 of file files.c.

References dcc, DCC_FILES, dcc_total, and dcc_users.

Referenced by cmd_files(), and dcc_files_pass().

{
  int i, n = 0;

  if (dcc_users == 0)
    return 0;
  for (i = 0; i < dcc_total; i++)
    if (dcc[i].type == &DCC_FILES)
      n++;
  return (n >= dcc_users);
}

Here is the caller graph for this function:

static int welcome_to_files

(

int

idx

)

[static]

Definition at line 76 of file files.c.

References botnet_send_join_idx, chanout_but, dcc, dccdir, dprintf, filedb_close(), filedb_open(), FILES_BROKEN, FILES_CURDIR, FILES_INVPATH, FILES_WELCOME, FILES_WELCOME1, FR_CHAN, FR_GLOBAL, get_user, flag_record::global, NULL, show_motd, STAT_CHAT, sub_lang, user, USER_JANITOR, USER_MASTER, and USERENTRY_DCCDIR.

Referenced by cmd_files(), and dcc_files_pass().

{
  struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };
  FILE *f;
  char *p = get_user(&USERENTRY_DCCDIR, dcc[idx].user);

  dprintf(idx, "\n");
  if (fr.global &USER_JANITOR)
    fr.global |=USER_MASTER;

  /* Show motd if the user went straight here without going thru the
   * party line.
   */
  if (!(dcc[idx].status & STAT_CHAT))
    show_motd(idx);
  sub_lang(idx, FILES_WELCOME);
  sub_lang(idx, FILES_WELCOME1);
  if (p)
    strcpy(dcc[idx].u.file->dir, p);
  else
    dcc[idx].u.file->dir[0] = 0;
  /* Does this dir even exist any more? */
  f = filedb_open(dcc[idx].u.file->dir, 0);
  if (f == NULL) {
    dcc[idx].u.file->dir[0] = 0;
    f = filedb_open(dcc[idx].u.file->dir, 0);
    if (f == NULL) {
      dprintf(idx, FILES_BROKEN);
      dprintf(idx, FILES_INVPATH);
      dprintf(idx, "\n\n");
      dccdir[0] = 0;
      chanout_but(-1, dcc[idx].u.file->chat->channel,
                  "*** %s rejoined the party line.\n", dcc[idx].nick);
      botnet_send_join_idx(idx, dcc[idx].u.file->chat->channel);
      return 0;                 /* failed */
    }
  }
  filedb_close(f);
  dprintf(idx, "%s: /%s\n\n", FILES_CURDIR, dcc[idx].u.file->dir);
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

cmd_t myfiles[] [static]

Definition at line 1351 of file files.c.

Referenced by filesys_close(), and filesys_start().