src/mod/transfer.mod/transfer.c File Reference

#include <sys/types.h>
#include <sys/stat.h>
#include "src/mod/module.h"
#include "src/tandem.h"
#include "src/users.h"
#include "transfer.h"
#include <netinet/in.h>
#include <arpa/inet.h>
#include "transferfstat.c"
#include "transferqueue.c"
#include "tcltransfer.c"

Include dependency graph for transfer.c:

Go to the source code of this file.

Defines
#define	MODULE_NAME "transfer"
#define	MAKING_TRANSFER
#define	PMAX_SIZE 4096
Functions
static int	wild_match_file (register char m, register char n)
static void	wipe_tmp_filename (char *fn, int idx)
static int	at_limit (char *nick)
static char *	replace_spaces (char *fn)
static void	dcc_fork_send (int idx, char *x, int y)
static void	dcc_get_pending (int idx, char *buf, int len)
static int	raw_dcc_resend_send (char filename, char nick, char from, char dir, int resend)
static int	raw_dcc_resend (char filename, char nick, char from, char dir)
static int	raw_dcc_send (char filename, char nick, char from, char dir)
static int	ctcp_DCC_RESUME (char nick, char from, char handle, char object, char keyword, char text)
static int	server_transfer_setup (char *mod)
static char *	transfer_close ()
static int	transfer_expmem ()
static void	transfer_report (int idx, int details)
char *	transfer_start ()
char *	transfer_start (Function *global_funcs)
Variables
static Function *	global = 0
static p_tcl_bind_list	H_rcvd
static p_tcl_bind_list	H_sent
static p_tcl_bind_list	H_lost
static p_tcl_bind_list	H_tout
static int	wait_dcc_xfer = 300
static int	dcc_limit = 3
static int	dcc_block = 0
static fileq_t *	fileq = 0
static struct dcc_table DCC_SEND DCC_GET	DCC_GET_PENDING
static struct dcc_table	DCC_FORK_SEND
static struct dcc_table	DCC_GET
static tcl_ints	myints []
static cmd_t	transfer_ctcps []
static cmd_t	transfer_load []
static Function	transfer_table []

Define Documentation

#define MAKING_TRANSFER

Definition at line 28 of file transfer.c.

#define MODULE_NAME "transfer"

Definition at line 27 of file transfer.c.

#define PMAX_SIZE 4096

Function Documentation

static int at_limit ( char * nick ) [static]

Definition at line 139 of file transfer.c.

References dcc, DCC_GET, DCC_GET_PENDING, dcc_limit, dcc_total, and egg_strcasecmp.

Referenced by do_dcc_send(), and fileq_cancel().

00140 {
00141   int i, x = 0;
00142 
00143   for (i = 0; i < dcc_total; i++)
00144     if ((dcc[i].type == &DCC_GET || dcc[i].type == &DCC_GET_PENDING) &&
00145         !egg_strcasecmp(dcc[i].nick, nick))
00146       x++;
00147 
00148   return (x >= dcc_limit);
00149 }

Here is the caller graph for this function:

static int ctcp_DCC_RESUME	(	char *	nick,
		char *	from,
		char *	handle,
		char *	object,
		char *	keyword,
		char *	text
	)			`[static]`

Definition at line 1072 of file transfer.c.

References dcc, DP_HELP, DP_SERVER, dprintf, egg_strcasecmp, killsock, killtransfer, lostdcc, my_atoul, newsplit, rfc_casecmp, TRANSFER_DCC_IGNORED, and XFER_RESUME_PEND.

01074 {
01075   char *action, *fn, buf[512], *msg = buf;
01076   int i, port;
01077   unsigned long offset;
01078 
01079   strcpy(msg, text);
01080   action = newsplit(&msg);
01081 
01082   if (egg_strcasecmp(action, "RESUME"))
01083     return 0;
01084 
01085   fn = newsplit(&msg);
01086   port = atoi(newsplit(&msg));
01087   offset = my_atoul(newsplit(&msg));
01088 
01089   for (i = 0; i < dcc_total; i++) /* Search for existing SEND */
01090     if ((dcc[i].type == &DCC_GET_PENDING) &&
01091         (!rfc_casecmp(dcc[i].nick, nick)) && (dcc[i].port == port))
01092       break;
01093   if (i == dcc_total) /* No matching transfer found? */
01094     return 0;
01095 
01096   if (dcc[i].u.xfer->length <= offset) {
01097     char *p = strrchr(dcc[i].u.xfer->origname, '/');
01098 
01099     dprintf(DP_HELP, TRANSFER_DCC_IGNORED, nick,
01100             p ? p + 1 : dcc[i].u.xfer->origname);
01101     killsock(dcc[i].sock);
01102     killtransfer(i);
01103     lostdcc(i);
01104     return 0;
01105   }
01106 
01107   dcc[i].u.xfer->type = XFER_RESUME_PEND;
01108   dcc[i].u.xfer->offset = offset;
01109   dprintf(DP_SERVER, "PRIVMSG %s :\001DCC ACCEPT %s %d %u\001\n", nick, fn, port,
01110           offset);
01111   return 1; /* Now we wait for the client to connect. */
01112 }

static void dcc_fork_send	(	int	idx,
		char *	x,
		int	y
	)			`[static]`

Definition at line 891 of file transfer.c.

References dcc, egg_snprintf, LOG_MISC, now, putlog, and TRANSFER_DCC_CONN.

00892 {
00893   char s1[121];
00894 
00895   if (dcc[idx].type != &DCC_FORK_SEND)
00896     return;
00897 
00898   dcc[idx].type = &DCC_SEND;
00899   dcc[idx].u.xfer->start_time = now;
00900 
00901   if (strcmp(dcc[idx].nick, "*users")) {
00902     egg_snprintf(s1, sizeof s1, "%s!%s", dcc[idx].nick, dcc[idx].host);
00903     putlog(LOG_MISC, "*", TRANSFER_DCC_CONN, dcc[idx].u.xfer->origname, s1);
00904   }
00905 }

static void dcc_get_pending	(	int	idx,
		char *	buf,
		int	len
	)			`[static]`

Definition at line 907 of file transfer.c.

References answer, dcc, dcc_block, DP_HELP, dprintf, killsock, LOG_FILES, lostdcc, neterror, now, putlog, TRANSFER_LOG_BAD_CONN, TRANSFER_NOTICE_BAD_CONN, UHOSTLEN, XFER_ACK_UNKNOWN, XFER_RESEND_PEND, XFER_RESUME, and XFER_RESUME_PEND.

00908 {
00909   unsigned long ip;
00910   unsigned short port;
00911   int i;
00912   char s[UHOSTLEN];
00913 
00914   i = answer(dcc[idx].sock, s, &ip, &port, 1);
00915   killsock(dcc[idx].sock);
00916   dcc[idx].sock = i;
00917   dcc[idx].addr = ip;
00918   dcc[idx].port = (int) port;
00919   if (dcc[idx].sock == -1) {
00920     neterror(s);
00921     dprintf(DP_HELP, TRANSFER_NOTICE_BAD_CONN, dcc[idx].nick, s);
00922     putlog(LOG_FILES, "*", TRANSFER_LOG_BAD_CONN, dcc[idx].u.xfer->origname,
00923            dcc[idx].nick, dcc[idx].host);
00924     fclose(dcc[idx].u.xfer->f);
00925     lostdcc(idx);
00926     return;
00927   }
00928 
00929   dcc[idx].type = &DCC_GET;
00930   dcc[idx].u.xfer->ack_type = XFER_ACK_UNKNOWN;
00931 
00932   /*
00933    * Note: The file was already opened and dcc[idx].u.xfer->f may be
00934    *       used immediately. Leave it opened until the file transfer
00935    *       is complete.
00936    */
00937 
00938   if (dcc[idx].u.xfer->type == XFER_RESUME_PEND) { /* Are we resuming? */
00939     int l;
00940 
00941     if (dcc_block == 0 || dcc[idx].u.xfer->length < dcc_block) {
00942       l = dcc[idx].u.xfer->length - dcc[idx].u.xfer->offset;
00943       dcc[idx].status = dcc[idx].u.xfer->length;
00944     } else {
00945       l = dcc_block;
00946       dcc[idx].status = dcc[idx].u.xfer->offset + dcc_block;
00947     }
00948 
00949     /* Seek forward ... */
00950     fseek(dcc[idx].u.xfer->f, dcc[idx].u.xfer->offset, SEEK_SET);
00951     dcc[idx].u.xfer->block_pending = pump_file_to_sock(dcc[idx].u.xfer->f,
00952                                                        dcc[idx].sock, l);
00953     dcc[idx].u.xfer->type = XFER_RESUME;
00954   } else {
00955     dcc[idx].u.xfer->offset = 0;
00956 
00957     /* If we're resending the data, wait for the client's response first,
00958      * before sending anything ourself.
00959      */
00960     if (dcc[idx].u.xfer->type != XFER_RESEND_PEND) {
00961       if (dcc_block == 0 || dcc[idx].u.xfer->length < dcc_block)
00962         dcc[idx].status = dcc[idx].u.xfer->length;
00963       else
00964         dcc[idx].status = dcc_block;
00965       dcc[idx].u.xfer->block_pending = pump_file_to_sock(dcc[idx].u.xfer->f,
00966                                                          dcc[idx].sock,
00967                                                          dcc[idx].status);
00968     } else
00969       dcc[idx].status = 0;
00970   }
00971 
00972   dcc[idx].timeval = dcc[idx].u.xfer->start_time = now;
00973 }

static int raw_dcc_resend	(	char *	filename,
		char *	nick,
		char *	from,
		char *	dir
	)			`[static]`

Definition at line 1059 of file transfer.c.

References raw_dcc_resend_send().

Referenced by _dcc_send().

01060 {
01061   return raw_dcc_resend_send(filename, nick, from, dir, 1);
01062 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int raw_dcc_resend_send	(	char *	filename,
		char *	nick,
		char *	from,
		char *	dir,
		int	resend
	)			`[static]`

Definition at line 981 of file transfer.c.

References dcc, DCCSEND_BADFN, DCCSEND_FEMPTY, DCCSEND_FULL, DCCSEND_NOSOCK, DCCSEND_OK, DIRLEN, DP_SERVER, dprintf, get_data_ptr, getmyip, iptolong, LOG_FILES, natip, new_dcc, nfree, NICKLEN, now, NULL, open_listen, putlog, replace_spaces(), reserved_port_max, reserved_port_min, strncpyz, TRANSFER_BEGIN_DCC, TRANSFER_RE, XFER_RESEND_PEND, and XFER_SEND.

Referenced by raw_dcc_resend(), and raw_dcc_send().

00983 {
00984   int zz, port, i;
00985   char *nfn, *buf = NULL;
00986   long dccfilesize;
00987   FILE *f, *dccfile;
00988 
00989   zz = -1;
00990   dccfile = fopen(filename, "r");
00991   if (!dccfile)
00992     return DCCSEND_BADFN;
00993   fseek(dccfile, 0, SEEK_END);
00994   dccfilesize = ftell(dccfile);
00995   fclose(dccfile);
00996 
00997   if (dccfilesize == 0)
00998     return DCCSEND_FEMPTY;
00999 
01000   if (reserved_port_min > 0 && reserved_port_min < reserved_port_max) {
01001     for (port = reserved_port_min; port <= reserved_port_max; port++)
01002       if ((zz = open_listen(&port)) != -1)
01003         break;
01004   } else {
01005     port = reserved_port_min;
01006     zz = open_listen(&port);
01007   }
01008 
01009   if (zz == -1)
01010     return DCCSEND_NOSOCK;
01011 
01012   nfn = strrchr(dir, '/');
01013   if (nfn == NULL)
01014     nfn = dir;
01015   else
01016     nfn++;
01017 
01018   f = fopen(filename, "r");
01019 
01020   if (!f)
01021     return DCCSEND_BADFN;
01022 
01023   if ((i = new_dcc(&DCC_GET_PENDING, sizeof(struct xfer_info))) == -1)
01024     return DCCSEND_FULL;
01025 
01026   dcc[i].sock = zz;
01027   dcc[i].addr = (IP) (-559026163);
01028   dcc[i].port = port;
01029   strcpy(dcc[i].nick, nick);
01030   strcpy(dcc[i].host, "irc");
01031   dcc[i].u.xfer->filename = get_data_ptr(strlen(filename) + 1);
01032   strcpy(dcc[i].u.xfer->filename, filename);
01033   if (strchr(nfn, ' '))
01034     nfn = buf = replace_spaces(nfn);
01035   dcc[i].u.xfer->origname = get_data_ptr(strlen(nfn) + 1);
01036   strcpy(dcc[i].u.xfer->origname, nfn);
01037   strncpyz(dcc[i].u.xfer->from, from, NICKLEN);
01038   strncpyz(dcc[i].u.xfer->dir, dir, DIRLEN);
01039   dcc[i].u.xfer->length = dccfilesize;
01040   dcc[i].timeval = now;
01041   dcc[i].u.xfer->f = f;
01042   dcc[i].u.xfer->type = resend ? XFER_RESEND_PEND : XFER_SEND;
01043 
01044   if (nick[0] != '*') {
01045     dprintf(DP_SERVER, "PRIVMSG %s :\001DCC %sSEND %s %lu %d %lu\001\n", nick,
01046             resend ? "RE" : "", nfn, iptolong(natip[0] ?
01047             (IP) inet_addr(natip) : getmyip()), port, dccfilesize);
01048     putlog(LOG_FILES, "*", TRANSFER_BEGIN_DCC, resend ? TRANSFER_RE : "", nfn,
01049            nick);
01050   }
01051 
01052   if (buf)
01053     nfree(buf);
01054 
01055   return DCCSEND_OK;
01056 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int raw_dcc_send	(	char *	filename,
		char *	nick,
		char *	from,
		char *	dir
	)			`[static]`

Definition at line 1065 of file transfer.c.

References raw_dcc_resend_send().

Referenced by _dcc_send(), remote_filereq(), send_next_file(), and start_sending_users().

01066 {
01067   return raw_dcc_resend_send(filename, nick, from, dir, 0);
01068 }

Here is the call graph for this function:

Here is the caller graph for this function:

static char* replace_spaces ( char * fn ) [static]

Definition at line 154 of file transfer.c.

References nmalloc, and NULL.

Referenced by raw_dcc_resend_send().

00155 {
00156   register char *ret, *p;
00157 
00158   p = ret = nmalloc(strlen(fn) + 1);
00159   strcpy(ret, fn);
00160   while ((p = strchr(p, ' ')) != NULL)
00161     *p = '_';
00162   return ret;
00163 }

Here is the caller graph for this function:

static int server_transfer_setup ( char * mod ) [static]

Definition at line 1132 of file transfer.c.

References add_builtins, find_bind_table, and H_ctcp.

Referenced by transfer_start().

01133 {
01134   p_tcl_bind_list H_ctcp;
01135 
01136   if ((H_ctcp = find_bind_table("ctcp")))
01137     add_builtins(H_ctcp, transfer_ctcps);
01138   return 1;
01139 }

Here is the caller graph for this function:

static char* transfer_close ( ) [static]

Definition at line 1141 of file transfer.c.

References dcc, del_bind_table, del_entry_type, del_lang_section, deq_this(), find_bind_table, H_ctcp, H_load, LOG_MISC, MODULE_NAME, module_undepend, NULL, putlog, rem_builtins, rem_help_reference, rem_tcl_commands, rem_tcl_ints, TRANSFER_UNLOADING, and USERENTRY_FSTAT.

01142 {
01143   int i;
01144   p_tcl_bind_list H_ctcp;
01145 
01146   putlog(LOG_MISC, "*", TRANSFER_UNLOADING);
01147   for (i = dcc_total - 1; i >= 0; i--) {
01148     if (dcc[i].type == &DCC_GET || dcc[i].type == &DCC_GET_PENDING)
01149       eof_dcc_get(i);
01150     else if (dcc[i].type == &DCC_SEND)
01151       eof_dcc_send(i);
01152     else if (dcc[i].type == &DCC_FORK_SEND)
01153       eof_dcc_fork_send(i);
01154   }
01155   while (fileq)
01156     deq_this(fileq);
01157   del_entry_type(&USERENTRY_FSTAT);
01158   del_bind_table(H_rcvd);
01159   del_bind_table(H_sent);
01160   del_bind_table(H_lost);
01161   del_bind_table(H_tout);
01162   rem_builtins(H_load, transfer_load);
01163   if ((H_ctcp = find_bind_table("ctcp"))) /* Try to remove our CTCP bindings */
01164     rem_builtins(H_ctcp, transfer_ctcps);
01165   rem_tcl_commands(mytcls);
01166   rem_tcl_ints(myints);
01167   rem_help_reference("transfer.help");
01168   del_lang_section("transfer");
01169   module_undepend(MODULE_NAME);
01170   return NULL;
01171 }

Here is the call graph for this function:

static int transfer_expmem ( ) [static]

Definition at line 1173 of file transfer.c.

References expmem_fileq().

Referenced by transfer_report().

01174 {
01175   return expmem_fileq();
01176 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void transfer_report	(	int	idx,
		int	details
	)			`[static]`

Definition at line 1178 of file transfer.c.

References dcc_block, dcc_limit, dprintf, transfer_expmem(), TRANSFER_STAT_1, and TRANSFER_STAT_2.

01179 {
01180   if (details) {
01181     int size = transfer_expmem();
01182 
01183     dprintf(idx, TRANSFER_STAT_1, dcc_block,
01184             (dcc_block == 0) ? " (turbo dcc)" : "");
01185     dprintf(idx, TRANSFER_STAT_2, dcc_limit);
01186     dprintf(idx, "    Using %d byte%s of memory\n", size,
01187             (size != 1) ? "s" : "");
01188   }
01189 }

Here is the call graph for this function:

char* transfer_start ( Function * global_funcs )

Definition at line 1224 of file transfer.c.

References add_bind_table, add_builtins, add_entry_type, add_help_reference, add_lang_section, add_tcl_commands, add_tcl_ints, def_get, user_entry_type::get, global, H_load, HT_STACKABLE, module_depend, MODULE_NAME, module_register, module_undepend, NULL, server_transfer_setup(), and USERENTRY_FSTAT.

01225 {
01226   global = global_funcs;
01227 
01228   fileq = NULL;
01229   module_register(MODULE_NAME, transfer_table, 2, 3);
01230   if (!module_depend(MODULE_NAME, "eggdrop", 106, 0)) {
01231     module_undepend(MODULE_NAME);
01232     return "This module requires Eggdrop 1.6.0 or later.";
01233   }
01234 
01235   add_tcl_commands(mytcls);
01236   add_tcl_ints(myints);
01237   add_builtins(H_load, transfer_load);
01238   server_transfer_setup(NULL);
01239   add_help_reference("transfer.help");
01240   H_rcvd = add_bind_table("rcvd", HT_STACKABLE, builtin_sentrcvd);
01241   H_sent = add_bind_table("sent", HT_STACKABLE, builtin_sentrcvd);
01242   H_lost = add_bind_table("lost", HT_STACKABLE, builtin_toutlost);
01243   H_tout = add_bind_table("tout", HT_STACKABLE, builtin_toutlost);
01244 
01245   USERENTRY_FSTAT.get = def_get;
01246   add_entry_type(&USERENTRY_FSTAT);
01247   add_lang_section("transfer");
01248   return NULL;
01249 }

Here is the call graph for this function:

char* transfer_start ( )

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

Definition at line 62 of file transfer.c.

References FILEMATCH, FILEQUOTE, FILEWILDQ, and FILEWILDS.

Referenced by _filedb_matchfile(), filedb_ls(), and fileq_cancel().

00063 {
00064   char *ma = m, *lsm = 0, *lsn = 0;
00065   int match = 1;
00066   register unsigned int sofar = 0;
00067 
00068   /* null strings should never match */
00069   if ((m == 0) || (n == 0) || (!*n))
00070     return 0;
00071 
00072   while (*n) {
00073     switch (*m) {
00074     case 0:
00075       do
00076         m--;
00077       while ((m > ma) && (*m == '?'));
00078       if ((m > ma) ? ((*m == '*') && (m[-1] != FILEQUOTE)) : (*m == '*'))
00079         return FILEMATCH;
00080       break;
00081     case FILEWILDS:
00082       do
00083         m++;
00084       while (*m == FILEWILDS);
00085       lsm = m;
00086       lsn = n;
00087       match += sofar;
00088       sofar = 0;
00089       continue;
00090     case FILEWILDQ:
00091       m++;
00092       n++;
00093       continue;
00094     case FILEQUOTE:
00095       m++;
00096     }
00097     if (*m == *n) {
00098       m++;
00099       n++;
00100       sofar++;
00101       continue;
00102     }
00103     if (lsm) {
00104       n = ++lsn;
00105       m = lsm;
00106       sofar = 0;
00107       continue;
00108     }
00109     return 0;
00110   }
00111   while (*m == FILEWILDS)
00112     m++;
00113   return (*m) ? 0 : FILEMATCH;
00114 }

Here is the caller graph for this function:

static void wipe_tmp_filename	(	char *	fn,
		int	idx
	)			`[static]`

Definition at line 117 of file transfer.c.

References copy_to_tmp, dcc, DCC_GET, DCC_GET_PENDING, and dcc_total.

Referenced by do_dcc_send(), fileq_cancel(), remote_filereq(), and send_next_file().

00118 {
00119   int i, ok = 1;
00120 
00121   if (!copy_to_tmp)
00122     return;
00123 
00124   for (i = 0; i < dcc_total; i++) {
00125     if ((i != idx) &&
00126         (dcc[i].type == &DCC_GET || dcc[i].type == &DCC_GET_PENDING) &&
00127         (!strcmp(dcc[i].u.xfer->filename, fn))) {
00128       ok = 0;
00129       break;
00130     }
00131   }
00132 
00133   if (ok)
00134     unlink(fn);
00135 }

Here is the caller graph for this function:

Variable Documentation

int dcc_block = 0 [static]

Definition at line 49 of file transfer.c.

Referenced by dcc_get_pending(), and transfer_report().

struct dcc_table DCC_FORK_SEND [static]

Initial value:

 {
  "FORK_SEND",
   0x00000400   |  0x00000100   |  0x00000800   |  0x00000010  ,
  eof_dcc_fork_send,
  dcc_fork_send,
  &wait_dcc_xfer,
  eof_dcc_fork_send,
  display_dcc_fork_send,
  expmem_dcc_xfer,
  kill_dcc_xfer,
  out_dcc_xfer
}

Definition at line 849 of file transfer.c.

Referenced by filesys_dcc_send(), filesys_dcc_send_hostresolved(), and share_ufsend().

struct dcc_table DCC_GET [static]

Initial value:

 {
  "GET",
   0x00000400   |  0x00000010  ,
  eof_dcc_get,
  dcc_get,
  &wait_dcc_xfer,
  transfer_get_timeout,
  display_dcc_get,
  expmem_dcc_xfer,
  kill_dcc_xfer,
  out_dcc_xfer,
  outdone_dcc_xfer
}

Definition at line 863 of file transfer.c.

Referenced by at_limit(), fileq_cancel(), share_report(), show_queued_files(), and wipe_tmp_filename().

static struct dcc_table DCC_GET_PENDING [static, read]

Initial value:

 {
  "GET_PENDING",
   0x00000400   |  0x00000010  ,
  eof_dcc_get,
  dcc_get_pending,
  &wait_dcc_xfer,
  transfer_get_timeout,
  display_dcc_get_p,
  expmem_dcc_xfer,
  kill_dcc_xfer,
  out_dcc_xfer
}

Definition at line 52 of file transfer.c.

Referenced by at_limit(), fileq_cancel(), show_queued_files(), and wipe_tmp_filename().

int dcc_limit = 3 [static]

Definition at line 48 of file transfer.c.

Referenced by at_limit(), and transfer_report().

fileq_t* fileq = 0 [static]

Definition at line 50 of file transfer.c.

Referenced by deq_this(), expmem_fileq(), fileq_cancel(), flush_fileq(), queue_file(), send_next_file(), and show_queued_files().

Function* global = 0 [static]

Definition at line 43 of file transfer.c.

p_tcl_bind_list H_lost [static]

Definition at line 45 of file transfer.c.

p_tcl_bind_list H_rcvd [static]

Definition at line 45 of file transfer.c.

p_tcl_bind_list H_sent [static]

Definition at line 45 of file transfer.c.

p_tcl_bind_list H_tout [static]

Definition at line 45 of file transfer.c.

tcl_ints myints[] [static]

Initial value:

 {
  {"max-dloads",       &dcc_limit},
  {"dcc-block",        &dcc_block},
  {"xfer-timeout", &wait_dcc_xfer},
  { 0 ,                      0 }
}

Definition at line 1114 of file transfer.c.

cmd_t transfer_ctcps[] [static]

Initial value:

 {
  {"DCC", "",  ctcp_DCC_RESUME, "transfer:DCC"},
  { 0 ,  0 ,  0 ,                       0 }
}

Definition at line 1121 of file transfer.c.

cmd_t transfer_load[] [static]

Initial value:

 {
  {"server", "", server_transfer_setup,  0 },
  { 0 ,     "",  0 ,                   0 }
}

Definition at line 1126 of file transfer.c.

Function transfer_table[] [static]

Initial value:

 {
  (Function) transfer_start,
  (Function) transfer_close,
  (Function) transfer_expmem,
  (Function) transfer_report,
  
  (Function) & DCC_FORK_SEND,   
  (Function) at_limit,
  (Function)  0 ,              
  (Function) fileq_cancel,
  
  (Function) queue_file,
  (Function) raw_dcc_send,
  (Function) show_queued_files,
  (Function) wild_match_file,
  
  (Function) wipe_tmp_filename,
  (Function) & DCC_GET,         
  (Function) & H_rcvd,          
  (Function) & H_sent,          
  
  (Function) & USERENTRY_FSTAT, 
  (Function)  0 ,              
  (Function) raw_dcc_resend,
  (Function) & H_lost,          
  
  (Function) & H_tout,          
  (Function) & DCC_SEND,        
  (Function) & DCC_GET_PENDING, 
}

Definition at line 1193 of file transfer.c.

int wait_dcc_xfer = 300 [static]

Definition at line 47 of file transfer.c.

src/mod/transfer.mod/transfer.c File Reference

Defines

Functions

Variables

Define Documentation

Function Documentation

Variable Documentation