static int my_send_file(struct asfd *asfd, struct FF_PKT *ff, struct conf **confs)
{
static struct sbuf *sb=NULL;
struct cntr *cntr=get_cntr(confs);
if(!sb && !(sb=sbuf_alloc(get_protocol(confs)))) return -1;
#ifdef HAVE_WIN32
if(ff->winattr & FILE_ATTRIBUTE_ENCRYPTED)
{
if(ff->type==FT_REG
|| ff->type==FT_DIR)
return to_server(asfd, confs, ff, sb, CMD_EFS_FILE);
return logw(asfd, cntr,
"EFS type %d not yet supported: %s\n",
ff->type, ff->fname);
}
#endif
switch(ff->type)
{
case FT_REG:
case FT_RAW:
case FT_FIFO:
return do_to_server(asfd, confs, ff, sb, filesymbol,
in_exclude_comp(get_strlist(confs[OPT_EXCOM]),
ff->fname, get_int(confs[OPT_COMPRESSION])));
case FT_DIR:
case FT_REPARSE:
case FT_JUNCTION:
return to_server(asfd, confs, ff, sb, dirsymbol);
case FT_LNK_S:
return to_server(asfd, confs, ff, sb, CMD_SOFT_LINK);
case FT_LNK_H:
return to_server(asfd, confs, ff, sb, CMD_HARD_LINK);
case FT_SPEC:
return to_server(asfd, confs, ff, sb, CMD_SPECIAL);
case FT_NOFSCHG:
return ft_err(asfd, confs, ff, "Will not descend: "
"file system change not allowed");
case FT_NOFOLLOW:
return ft_err(asfd, confs, ff, "Could not follow link");
case FT_NOSTAT:
return ft_err(asfd, confs, ff, "Could not stat");
case FT_NOOPEN:
return ft_err(asfd, confs, ff, "Could not open directory");
default:
return logw(asfd, cntr,
"Err: Unknown file type %d: %s\n",
ff->type, ff->fname);
}
}
int send_file(struct asfd *asfd, FF_PKT *ff, bool top_level, struct conf *conf)
{
static struct sbuf *sb=NULL;
if(!sb && !(sb=sbuf_alloc(conf))) return -1;
if(!file_is_included(conf, ff->fname, top_level)) return 0;
#ifdef HAVE_WIN32
if(ff->winattr & FILE_ATTRIBUTE_ENCRYPTED)
{
if(ff->type==FT_REG
|| ff->type==FT_DIR)
return to_server(asfd, conf, ff, sb, CMD_EFS_FILE);
return logw(asfd, conf, "EFS type %d not yet supported: %s",
ff->type, ff->fname);
}
#endif
switch(ff->type)
{
case FT_REG:
case FT_RAW:
case FT_FIFO:
return do_to_server(asfd, conf, ff, sb, filesymbol,
in_exclude_comp(conf->excom,
ff->fname, conf->compression));
case FT_DIR:
case FT_REPARSE:
case FT_JUNCTION:
return to_server(asfd, conf, ff, sb, dirsymbol);
case FT_LNK_S:
return to_server(asfd, conf, ff, sb, CMD_SOFT_LINK);
case FT_LNK_H:
return to_server(asfd, conf, ff, sb, CMD_HARD_LINK);
case FT_SPEC:
return to_server(asfd, conf, ff, sb, CMD_SPECIAL);
case FT_NOFSCHG:
return logw(asfd, conf, "Dir: %s [will not descend: "
"file system change not allowed]\n", ff->fname);
case FT_NOFOLLOW:
return ft_err(asfd, conf, ff, "Could not follow link");
case FT_NOSTAT:
return ft_err(asfd, conf, ff, "Could not stat");
case FT_NOOPEN:
return ft_err(asfd, conf, ff, "Could not open directory");
default:
return logw(asfd, conf,
_("Err: Unknown file type %d: %s"),
ff->type, ff->fname);
}
}
void check_kicksay(Chan *chan, ChanUser *doer, char *text)
{
KickSay *kick,*save;
char *mask;
int action;
save = NULL;
action = -1;
for(kick=current->kicklist;kick;kick=kick->next)
{
if (*kick->chan == '*' || !Strcasecmp(chan->name,kick->chan))
{
if (!matches(kick->mask,text))
{
if (kick->action > action)
{
action = kick->action;
save = kick;
}
}
}
}
if (save)
{
if (!action)
{
if (doer->flags & CU_KSWARN)
action = 1;
if (!(doer->flags & CU_KSWARN))
{
doer->flags |= CU_KSWARN;
to_server("NOTICE %s :%s\n",doer->nick,save->reason);
}
}
if (action > 1)
{
mask = format_uh(get_nuh(doer),FUH_USERHOST);
if (action > 2)
{
add_shit("Auto KS",chan->name,mask,save->reason,2,now+3600);
}
if (!(doer->flags & CU_BANNED))
{
doer->flags |= CU_BANNED;
send_mode(chan,90,QM_RAWMODE,'+','b',mask);
}
}
if (action && !(doer->flags & CU_KICKED))
{
doer->flags |= CU_KICKED;
send_kick(chan,CurrentNick,FMT_PLAIN,save->reason);
}
}
}
int
run_client (u_short port,
ACE_MEM_IO::Signal_Strategy strategy)
{
int status = 0;
ACE_MEM_Addr to_server (port);
ACE_MEM_Connector connector;
connector.preferred_strategy (strategy);
ACE_MEM_Stream stream;
// connector.preferred_strategy (ACE_MEM_IO::MT);
if (connector.connect (stream, to_server.get_remote_addr ()) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Failed to connect to <%C> %p\n"),
to_server.get_host_name (),
ACE_TEXT ("connector.connect()")),
-1);
ACE_TCHAR buf[MAXPATHLEN];
for (size_t cntr = 0; cntr < NUMBER_OF_ITERATIONS; cntr ++)
{
ACE_OS::snprintf (buf, MAXPATHLEN,
ACE_TEXT ("Iteration ") ACE_SIZE_T_FORMAT_SPECIFIER,
cntr);
ssize_t slen = (ACE_OS::strlen (buf) + 1) * sizeof (ACE_TCHAR);
if (stream.send (buf, slen) < slen)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"),
ACE_TEXT ("In stream.send()")));
status = -1;
break;
}
if (stream.recv (buf, MAXPATHLEN) == -1)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"),
ACE_TEXT ("stream.recv()")));
status = -1;
break;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("run_client(), got echo %s\n"),
buf));
}
status = stream.close () == -1 ? -1 : status;
return status;
}
void do_random_msg(COMMAND_ARGS)
{
char *filename,*message;
filename = CurrentCmd->cmdarg;
if (*rest)
{
to = chop(&rest);
if (ischannel(to) && (get_authaccess(from,to) < cmdaccess))
return;
}
else
if (!ischannel(to))
{
usage(from); /* usage for CurrentCmd->name */
return;
}
if ((message = randstring(filename)) == NULL)
{
to_user(from,ERR_FILEOPEN,filename);
return;
}
/*
* send message to target nick/channel
*/
to_server("PRIVMSG %s :%s\n",to,message);
/*
* if its not a channel we send a copy to the user who did the command also
*/
if (!ischannel(to))
{
to_user(from,"(%s) %s",to,message);
}
}
void do_randtopic(COMMAND_ARGS)
{
/*
* on_msg checks CAXS
*/
Chan *chan = CurrentChan;
char *topic;
/*
* the bot can set a random topic if chanmode is -t
*/
if (chan->bot_is_op || chan->topprot == FALSE)
{
if ((topic = randstring(RANDTOPICSFILE)) == NULL)
{
to_user(from,ERR_FILEOPEN,RANDTOPICSFILE);
return;
}
to_server("TOPIC %s :%s\n",to,topic);
to_user(from,TEXT_TOPICCHANGED,to);
return;
}
to_user(from,ERR_NOTOPPED,to);
}
static gboolean network_send_line_direct(struct irc_network *s, struct irc_client *c,
const struct irc_line *ol, GError **error)
{
struct irc_line nl, *l;
struct network_config *nc = s->private_data;
g_assert(nc != NULL);
g_assert(nc->type == NETWORK_TCP ||
nc->type == NETWORK_PROGRAM ||
nc->type == NETWORK_IOCHANNEL ||
nc->type == NETWORK_VIRTUAL);
l = &nl;
memcpy(l, ol, sizeof(struct irc_line));
nl.origin = NULL;
/* origin lines should never be sent to the server */
g_assert(l->origin == NULL);
if (nc->type == NETWORK_VIRTUAL) {
g_assert (s->connection.data.virtual.ops != NULL) ;
return s->connection.data.virtual.ops->to_server(s, c, l);
} else {
void send_spy(const char *src, const char *format, ...)
{
Chan *chan;
Mech *backup;
Spy *spy;
va_list msg;
const char *tempsrc;
char tempdata[MAXLEN];
int fd;
int printed = FALSE;
tempsrc = (src == SPYSTR_STATUS) ? time2medium(now) : src;
#ifdef DEBUG
debug("(send_spy) src %s format = '%s'\n",src,format);
#endif /* DEBUG */
for(spy=current->spylist;spy;spy=spy->next)
{
if ((*src == '#' || *src == '*') && spy->t_src == SPY_CHANNEL)
{
if ((*src != '*') && stringcasecmp(spy->src,src))
continue;
if ((chan = find_channel_ac(spy->src)) == NULL)
continue;
if (find_chanuser(chan,CurrentNick) == NULL)
continue;
tempsrc = spy->src;
}
else
/*
* by using string constants we can compare addresses
*/
if (spy->src != src)
continue;
if (!printed)
{
printed = TRUE;
va_start(msg,format);
vsprintf(tempdata,format,msg);
va_end(msg);
}
switch(spy->t_dest)
{
case SPY_DCC:
to_file(spy->dcc->sock,"[%s] %s\n",tempsrc,tempdata);
break;
case SPY_CHANNEL:
if (spy->destbot >= 0)
{
backup = current;
for(current=botlist;current;current=current->next)
{
if (current->guid == spy->destbot)
{
to_server("PRIVMSG %s :[%s] %s\n",spy->dest,tempsrc,tempdata);
break;
}
}
current = backup;
}
else
{
to_user(spy->dest,"[%s] %s",tempsrc,tempdata);
}
break;
case SPY_FILE:
if ((fd = open(spy->dest,O_WRONLY|O_CREAT|O_APPEND,NEWFILEMODE)) >= 0)
{
to_file(fd,"[%s] %s\n",logtime(now),tempdata);
close(fd);
}
}
}
}
