2162 lines
62 KiB
C
Executable File
2162 lines
62 KiB
C
Executable File
/************************************************************************/
|
|
/* */
|
|
/* ***** ***** */
|
|
/* ***** ***** */
|
|
/* ***** ***** */
|
|
/* ***** ***** */
|
|
/* *************** *************** */
|
|
/* ***************** ***************** */
|
|
/* *************** *************** */
|
|
/* ***** ***** TheNetNode */
|
|
/* ***** ***** Portable */
|
|
/* ***** ***** Network */
|
|
/* ***** ***** Software */
|
|
/* */
|
|
/* File src/cvs_cvsd.c (maintained by: DL1XAO) */
|
|
/* */
|
|
/* This file is part of "TheNetNode" - Software Package */
|
|
/* */
|
|
/* Copyright (C) 1998 - 2008 NORD><LINK e.V. Braunschweig */
|
|
/* */
|
|
/* This program is free software; you can redistribute it and/or modify */
|
|
/* it under the terms of the NORD><LINK ALAS (Allgemeine Lizenz fuer */
|
|
/* Amateurfunk Software) as published by Hans Georg Giese (DF2AU) */
|
|
/* on 13/Oct/1992; either version 1, or (at your option) any later */
|
|
/* version. */
|
|
/* */
|
|
/* This program is distributed WITHOUT ANY WARRANTY only for further */
|
|
/* development and learning purposes. See the ALAS (Allgemeine Lizenz */
|
|
/* fuer Amateurfunk Software). */
|
|
/* */
|
|
/* You should have received a copy of the NORD><LINK ALAS (Allgemeine */
|
|
/* Lizenz fuer Amateurfunk Software) along with this program; if not, */
|
|
/* write to NORD><LINK e.V., Hinter dem Berge 5, D-38108 Braunschweig */
|
|
/* */
|
|
/* Dieses Programm ist PUBLIC DOMAIN, mit den Einschraenkungen durch */
|
|
/* die ALAS (Allgemeine Lizenz fuer Amateurfunk Software), entweder */
|
|
/* Version 1, veroeffentlicht von Hans Georg Giese (DF2AU), */
|
|
/* am 13.Oct.1992, oder (wenn gewuenscht) jede spaetere Version. */
|
|
/* */
|
|
/* Dieses Programm wird unter Haftungsausschluss vertrieben, aus- */
|
|
/* schliesslich fuer Weiterentwicklungs- und Lehrzwecke. Naeheres */
|
|
/* koennen Sie der ALAS (Allgemeine Lizenz fuer Amateurfunk Software) */
|
|
/* entnehmen. */
|
|
/* */
|
|
/* Sollte dieser Software keine ALAS (Allgemeine Lizenz fuer Amateur- */
|
|
/* funk Software) beigelegen haben, wenden Sie sich bitte an */
|
|
/* NORD><LINK e.V., Hinter dem Berge 5, D-38108 Braunschweig */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
/*
|
|
* $Log$
|
|
*/
|
|
|
|
/*
|
|
* This is Ping-Pong convers/conversd derived from the wampes
|
|
* convers package written by Dieter Deyke <deyke@hpfcmdd.fc.hp.com>
|
|
*
|
|
* Modifications by Fred Baumgarten <dc6iq@insl1.etec.uni-karlsruhe.de>
|
|
* $Revision: 3.12 $$Date: 1996/03/03 10:09:47 $
|
|
*
|
|
* Modifications by Oliver Kern <daa531@gmx.de>
|
|
* $Revision: 3.13 $$Date: 17.08.2004 22:22 $
|
|
*/
|
|
/* modified for use with TheNetNode by DL1XAO */
|
|
/* hierdrin befinden sich alle Senderoutinen und sonstiges,
|
|
welches sich nicht mit Datenstrukturen von TNN befasst */
|
|
#include "tnn.h"
|
|
|
|
#ifdef PPCONVERS
|
|
|
|
#include "conversd.h"
|
|
|
|
static char *persfile;
|
|
static WORD isonchannel __ARGS((CONNECTION *cp, char *user, char *host));
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
void appenddirect(CONNECTION *cp, const char *string)
|
|
{
|
|
if (cp->up)
|
|
putcvsstr(cp, (char *)string);
|
|
}
|
|
|
|
void appendformline(CONNECTION *cp, char *prefix, char *text)
|
|
{
|
|
char buf[258], *d, *s1, *s2;
|
|
WORD prefixlen, l, linelen;
|
|
|
|
if (cp->up) {
|
|
text = convertout(cp->charset_out, (char *)text);
|
|
linelen = cp->width - 1;
|
|
l = prefixlen = (WORD)strlen(prefix);
|
|
strcpy(buf, prefix);
|
|
d = buf + prefixlen;
|
|
*d++ = ' ';
|
|
|
|
while (*text) {
|
|
|
|
while (isspace(uchar(*text)))
|
|
text++;
|
|
|
|
if (*text) {
|
|
while (*text && !isspace(uchar(*text)) && l < linelen) {
|
|
*d++ = *text++;
|
|
l++;
|
|
}
|
|
while (isspace(uchar(*text)) && l < linelen) {
|
|
s1 = text;
|
|
while (isspace(uchar(*s1)))
|
|
s1++;
|
|
s2 = s1;
|
|
while (*s2 && !isspace(uchar(*s2)))
|
|
s2++;
|
|
if (l + (WORD)(s2 - text) < linelen) {
|
|
while (text < s2) {
|
|
*d++ = *text++;
|
|
l++;
|
|
}
|
|
}
|
|
else if ((WORD)(s2 - s1) > (linelen - prefixlen)) {
|
|
while (l < linelen) {
|
|
*d++ = *text++;
|
|
l++;
|
|
}
|
|
}
|
|
else
|
|
text = s1;
|
|
}
|
|
if (*(d-1) != '\r')
|
|
*d++ = '\r';
|
|
*d = '\0';
|
|
putcvsstr(cp, buf);
|
|
for (l = 0, d = buf; l < prefixlen; l++)
|
|
*d++ = ' ';
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void appendstring(CONNECTION *cp, const char *string)
|
|
{
|
|
char *p_string;
|
|
|
|
if (cp->up && *string) {
|
|
|
|
if (cp->type == CT_USER)
|
|
p_string = convertout(cp->charset_out, (char *)string);
|
|
else
|
|
p_string = (char *)string;
|
|
|
|
putcvsstr(cp, (char *)p_string);
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
/* zusammengefasste Variante von appendprompt/appendc */
|
|
|
|
void appendprompt(CONNECTION *cp, const WORD ast)
|
|
{
|
|
char x[3], *p;
|
|
|
|
#ifdef L1IRC
|
|
if (cp->IrcMode)
|
|
return;
|
|
#endif /* L1IRC */
|
|
|
|
if (ast == 2) {
|
|
p = x;
|
|
if (cp->prompt[0])
|
|
*p++ = cp->prompt[0];
|
|
if (cp->prompt[3])
|
|
*p++ = cp->prompt[3];
|
|
*p = '\0';
|
|
if (p != x)
|
|
appenddirect(cp, x);
|
|
}
|
|
else if ((*x = cp->prompt[(*cp->query) ? 1 : 2]) != 0) {
|
|
x[1] = '\0';
|
|
appenddirect(cp, x);
|
|
}
|
|
else if (ast)
|
|
appenddirect(cp, "***\r");
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
void destroy_channel(WORD number)
|
|
{
|
|
CHANNEL *ch, *ch1;
|
|
|
|
ch1 = NULLCHANNEL;
|
|
for (ch = channels; ch; ch = ch->next) {
|
|
if (ch->chan == number) {
|
|
if (ch1) {
|
|
ch1->next = ch->next;
|
|
} else {
|
|
channels = ch->next;
|
|
}
|
|
if (ch->topic)
|
|
free(ch->topic);
|
|
|
|
#ifdef CONV_TOPIC
|
|
/* Call loeschen. */
|
|
ch->name[0] = 0;
|
|
#endif
|
|
free(ch);
|
|
break;
|
|
}
|
|
ch1 = ch;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
PERMLINK *permlink_of(CONNECTION *cp)
|
|
{
|
|
WORD pl;
|
|
PERMLINK *l;
|
|
|
|
for (pl = 0; pl < MAXCVSHOST; pl++) {
|
|
l = permarray[pl];
|
|
if (l && l->connection == cp)
|
|
return(l);
|
|
}
|
|
return(NULL);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
void free_closed_connections()
|
|
{
|
|
CONNECTION *cp, *p;
|
|
PERMLINK *l;
|
|
WORD to;
|
|
|
|
for (p = NULLCONNECTION, cp = connections; cp; ) {
|
|
l = cp->via ? NULL : permlink_of(cp);
|
|
to = 0;
|
|
if (l && cp->type == CT_UNKNOWN && cp->time + l->waittime - 5 < currtime) {
|
|
send_proto("cvsd", "timeout for %s", cp->name);
|
|
to = 1;
|
|
}
|
|
|
|
if ( cp->type == CT_CLOSED
|
|
|| to
|
|
||(!l && cp->type == CT_UNKNOWN))
|
|
{
|
|
if (p)
|
|
{
|
|
p->next = cp->next;
|
|
free_connection(cp);
|
|
cp = p->next;
|
|
}
|
|
else
|
|
{
|
|
connections = cp->next;
|
|
free_connection(cp);
|
|
cp = connections;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p = cp;
|
|
cp = cp->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
char *getarg(char *line, WORD mode)
|
|
{
|
|
char *arg;
|
|
WORD c;
|
|
static char *p;
|
|
|
|
#ifdef CONVNICK
|
|
int mke = FALSE;
|
|
#endif
|
|
|
|
if (line) p = line;
|
|
while (isspace(uchar(*p))) p++;
|
|
if (mode == GET_ALL) return(p);
|
|
arg = p;
|
|
if (mode == GET_NXTCS)
|
|
while (*p && !isspace(uchar(*p)))
|
|
p++;
|
|
else
|
|
while (*p && !isspace(uchar(*p)))
|
|
{
|
|
#ifdef CONVNICK
|
|
if (mke == TRUE || (*p == ':'))
|
|
{
|
|
c = (uchar(*p));
|
|
mke = TRUE;
|
|
}
|
|
else
|
|
#endif
|
|
c = tolower(uchar(*p));
|
|
#ifdef __WIN32__
|
|
*p++ = (char)c;
|
|
#else
|
|
*p++ = c;
|
|
#endif /* WIN32 */
|
|
}
|
|
|
|
if (*p)
|
|
*p++ = '\0';
|
|
|
|
return(arg);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
char *ts(time_t gmt)
|
|
{
|
|
static char buffer[80];
|
|
static char monthnames[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
|
|
struct tm *tm;
|
|
|
|
tm = localtime(&gmt);
|
|
if (gmt + 24L * 60L * 60L > currtime)
|
|
sprintf(buffer, " %2d:%02d", tm->tm_hour, tm->tm_min);
|
|
else
|
|
sprintf(buffer, "%-3.3s %2d", monthnames + 3 * tm->tm_mon, tm->tm_mday);
|
|
return(buffer);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
void ts2(void)
|
|
{
|
|
struct tm *tm;
|
|
|
|
tm = localtime(&currtime);
|
|
sprintf(timestamp, "*** (%2d:%02d) ", tm->tm_hour, tm->tm_min);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
char *ts3(time_t seconds, char *buffer)
|
|
{
|
|
if (seconds < 100L) {
|
|
sprintf(buffer, "%ds", (WORD)seconds);
|
|
} else if (seconds <6000L) {
|
|
sprintf(buffer, "%dm", (WORD)(seconds/60L));
|
|
} else if (seconds <360000L) {
|
|
sprintf(buffer, "%dh", (WORD)(seconds/3600L));
|
|
} else {
|
|
sprintf(buffer, "%dd", (WORD)(seconds/86400L));
|
|
}
|
|
return(buffer);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
char *ts4(time_t seconds)
|
|
{
|
|
time_t days, hours, minutes;
|
|
static char buffer[64];
|
|
char *bp;
|
|
|
|
days = seconds / 86400L;
|
|
seconds -= days * 86400L;
|
|
hours = seconds / 3600L;
|
|
seconds -= hours * 3600L;
|
|
minutes = seconds / 60L;
|
|
seconds -= minutes * 60L;
|
|
|
|
bp = buffer;
|
|
if (days)
|
|
bp += sprintf(bp, "%d days, ", (WORD)days);
|
|
if (days+hours)
|
|
bp += sprintf(bp, "%d hours, ", (WORD)hours);
|
|
if (days+hours+minutes)
|
|
bp += sprintf(bp, "%d minutes, ", (WORD)minutes);
|
|
sprintf(bp, "%d seconds.", (WORD)seconds);
|
|
|
|
return(buffer);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
WORD count_user(WORD channel)
|
|
{
|
|
CONNECTION *p;
|
|
CLIST *cl;
|
|
WORD n = 0;
|
|
|
|
for (p = connections; p; p = p->next) {
|
|
if (p->type == CT_USER) {
|
|
if (p->via && (p->channel == channel)) {
|
|
n++;
|
|
} else {
|
|
for (cl = p->chan_list; cl; cl = cl->next) {
|
|
if (cl->channel == channel) {
|
|
n++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return(n);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
void clear_locks()
|
|
{
|
|
CONNECTION *p;
|
|
|
|
for (p = connections; p; p = p->next) p->locked = 0;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
static WORD isonchannel(CONNECTION *cp, char *user, char *host)
|
|
{
|
|
CONNECTION *p;
|
|
CLIST *cl, *cl1;
|
|
|
|
for (p = connections; p; p = p->next)
|
|
if (p->type == CT_USER && p != cp)
|
|
if (!Strcmp(p->name, user) && !Strcmp(p->host, host))
|
|
for (cl = cp->chan_list; cl; cl = cl->next) {
|
|
if (p->channel == cl->channel)
|
|
return(1);
|
|
for (cl1 = p->chan_list; cl1; cl1 = cl1->next)
|
|
if (cl1->channel == cl->channel)
|
|
return(1);
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
#ifndef CONVNICK
|
|
void send_awaymsg(char *fromname,.char *hostname,
|
|
#else
|
|
void send_awaymsg(char *fromname, char *fromnickname, char *hostname,
|
|
#endif /* CONVNICK */
|
|
time_t time, char *text)
|
|
{
|
|
char buffer[2048];
|
|
char namefilt[68], *c;
|
|
register CONNECTION *p;
|
|
|
|
sprintf(namefilt, " %s ", fromname);
|
|
if ((c = strchr(namefilt, ':')) != NULL) {
|
|
*c++ = ' ';
|
|
*c = NUL;
|
|
}
|
|
for (p = connections; p; p = p->next) {
|
|
#ifdef L1IRC
|
|
if (p->IrcMode)
|
|
{
|
|
if (!p->locked && (p->type == CT_HOST || (p->type == CT_USER && !p->via && p->verbose && isonchannel(p, fromname, hostname))))
|
|
{
|
|
sprintf(buffer, ":%s!%s@%s MODE %s %ca%s%s\n", fromname, fromname, hostname, fromname, *text ? '+' : '-', (*text ? " :" : ""), (*text ? text : ""));
|
|
appendstring(p, buffer);
|
|
p->locked = 1;
|
|
continue;
|
|
}
|
|
}
|
|
#endif /* L1IRC */
|
|
if (p->type == CT_HOST) {
|
|
if (!p->locked) {
|
|
sprintf(buffer, "/\377\200AWAY %s %s %ld %s\r", fromname, hostname, (long)time, text);
|
|
appenddirect(p, buffer);
|
|
p->locked = 1;
|
|
send_proto("cvsd", "TX to %s %s", p->name, buffer+3);
|
|
}
|
|
} else {
|
|
if (!p->via && !p->locked) {
|
|
if (isonchannel(p, fromname, hostname)) {
|
|
if (!(p->filter && strstr(p->filter, namefilt))) {
|
|
appendprompt(p, 2);
|
|
if (*text != '\0')
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(6), timestamp, fromname, hostname, text);
|
|
#else
|
|
sprintf(buffer, "%s%s@%s has gone away:\r %s\r", timestamp, fromname, hostname, text);
|
|
#endif
|
|
else
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(7), timestamp, fromname, hostname);
|
|
#else
|
|
sprintf(buffer, "%s%s@%s is back again.\r", timestamp, fromname, hostname);
|
|
#endif
|
|
#ifdef L1IRC
|
|
if (p->IrcMode == TRUE) /* IRC-Client. */
|
|
{
|
|
if (*text != '\0') /* Abmelden. */
|
|
sprintf(buffer, ":%s 301 %s %s : %s\n" /* IRC-Meldung */
|
|
, myhostname /* vorbereiten. */
|
|
, fromname
|
|
, (*fromnickname ? fromnickname : fromname)
|
|
, text);
|
|
else /* Anmelden. */
|
|
sprintf(buffer, ":%s 320 %s %s : is back\n" /* IRC-Meldung */
|
|
, myhostname /* vorbereiten. */
|
|
, fromname
|
|
, (*fromnickname ? fromnickname : fromname));
|
|
}
|
|
#endif /* L1IRC */
|
|
appendstring(p, buffer);
|
|
appendprompt(p, 0);
|
|
}
|
|
}
|
|
p->locked = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
#ifndef L1IRC
|
|
void send_mode(CHANNEL *ch)
|
|
#else
|
|
void send_mode(CHANNEL *ch, CONNECTION *cp, WORD oldflags)
|
|
#endif /* L1IRC */
|
|
{
|
|
register CONNECTION *p;
|
|
char buffer[2048];
|
|
char *flags;
|
|
#ifdef L1IRC
|
|
char flags_irc[16];
|
|
char oldflags_irc[16];
|
|
|
|
flags_irc[0] = '\0';
|
|
oldflags_irc[0] = '\0';
|
|
|
|
if (ch->flags & M_CHAN_S)
|
|
{
|
|
if (!(oldflags & M_CHAN_S))
|
|
strcat(flags_irc, "p");
|
|
}
|
|
|
|
if (ch->flags & M_CHAN_P)
|
|
{
|
|
if (!(oldflags & M_CHAN_P))
|
|
strcat(flags_irc, "i");
|
|
}
|
|
|
|
if (ch->flags & M_CHAN_T)
|
|
{
|
|
if (!(oldflags & M_CHAN_T))
|
|
strcat(flags_irc, "t");
|
|
}
|
|
|
|
if (ch->flags & M_CHAN_I)
|
|
{
|
|
if (!(oldflags & M_CHAN_I))
|
|
strcat(flags_irc, "s");
|
|
}
|
|
|
|
if (ch->flags & M_CHAN_M)
|
|
{
|
|
if (!(oldflags & M_CHAN_M))
|
|
strcat(flags_irc, "m");
|
|
}
|
|
|
|
if ((oldflags & M_CHAN_S) && !(ch->flags & M_CHAN_S))
|
|
strcat(oldflags_irc, "p");
|
|
|
|
if ((oldflags & M_CHAN_P) && !(ch->flags & M_CHAN_P))
|
|
strcat(oldflags_irc, "i");
|
|
|
|
if ((oldflags & M_CHAN_T) && !(ch->flags & M_CHAN_T))
|
|
strcat(oldflags_irc, "t");
|
|
|
|
if ((oldflags & M_CHAN_I) && !(ch->flags & M_CHAN_I))
|
|
strcat(oldflags_irc, "s");
|
|
|
|
if ((oldflags & M_CHAN_M) && !(ch->flags & M_CHAN_M))
|
|
strcat(oldflags_irc, "m");
|
|
#endif /* L1IRC */
|
|
|
|
flags = getflags(ch->flags);
|
|
for (p = connections; p; p = p->next) {
|
|
#ifdef L1IRC
|
|
if (p->IrcMode == FALSE)
|
|
{
|
|
#endif /* L1IRC */
|
|
if ((p->type == CT_HOST) && !p->locked) {
|
|
sprintf(buffer, "/\377\200MODE %d -sptiml+%s\r", ch->chan, flags);
|
|
appenddirect(p, buffer);
|
|
send_proto("cvsd", "TX to %s %s", p->name, buffer+3);
|
|
}
|
|
#ifdef L1IRC
|
|
}
|
|
else
|
|
{
|
|
struct clist *cl2;
|
|
char *fromname;
|
|
|
|
if ((p->type == CT_HOST || p->type == CT_USER))
|
|
{
|
|
if (p->type == CT_USER && !(p->operator == 2 && p->verbose))
|
|
{
|
|
if (p->channel != ch->chan)
|
|
{
|
|
for (cl2 = p->chan_list; cl2; cl2 = cl2->next)
|
|
{
|
|
if (cl2->channel == ch->chan)
|
|
break;
|
|
}
|
|
|
|
if (!cl2)
|
|
continue;
|
|
}
|
|
}
|
|
|
|
fromname = ((cp) ? ((cp->type == CT_HOST) ? cp->name : cp->nickname) : myhostname);
|
|
sprintf(buffer, ":%s MODE #%d %s%s%s%s\n", fromname, ch->chan, (*oldflags_irc) ? "-" : "", oldflags_irc, (*flags_irc) ? "+" : "", flags_irc);
|
|
appendstring(p, buffer);
|
|
}
|
|
}
|
|
|
|
p->locked = 1;
|
|
#endif /* L1IRC */
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
#ifndef L1IRC
|
|
void send_opermsg(char *toname, char *hostname, char *fromname, WORD channel)
|
|
#else
|
|
void send_opermsg(char *toname, char *hostname, char *fromname, WORD channel, int status_really_changed)
|
|
#endif /* L1IRC */
|
|
{
|
|
char buffer[2048];
|
|
register CONNECTION *p;
|
|
CLIST *cl;
|
|
|
|
for (p = connections; p; p = p->next) {
|
|
if (!p->locked) {
|
|
#ifdef L1IRC
|
|
int ison = 0;
|
|
|
|
if (channel >= 0)
|
|
{
|
|
ison = 0;
|
|
|
|
if (p->channel == channel)
|
|
ison = 1;
|
|
else
|
|
{
|
|
for (cl = p->chan_list; cl; cl = cl->next)
|
|
{
|
|
if (cl->channel == channel)
|
|
{
|
|
ison = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (p->IrcMode == TRUE)
|
|
{
|
|
if (channel == EOF)
|
|
{
|
|
if (p->type == CT_HOST || (p->type == CT_USER && (p->verbose || !strcasecmp(toname, p->name)) && status_really_changed))
|
|
{
|
|
sprintf(buffer, ":%s MODE %s +o\n", fromname, toname);
|
|
appendstring(p, buffer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (p->type != CT_USER && p->type != CT_HOST)
|
|
continue;
|
|
|
|
if (p->type == CT_USER)
|
|
{
|
|
if (p->via || !status_really_changed)
|
|
continue;
|
|
|
|
if (!ison)
|
|
{
|
|
if (!p->verbose)
|
|
continue;
|
|
}
|
|
}
|
|
|
|
sprintf(buffer, ":%s MODE #%d +o %s\n", fromname, channel, toname);
|
|
appendstring(p, buffer);
|
|
}
|
|
}
|
|
#endif /* L1IRC */
|
|
if (p->type == CT_HOST) {
|
|
sprintf(buffer, "/\377\200OPER %s %d %s\r", fromname, channel, toname);
|
|
appenddirect(p, buffer);
|
|
p->locked = 1;
|
|
send_proto("cvsd", "TX to %s %s", p->name, buffer+3);
|
|
} else {
|
|
if (p->type == CT_USER) {
|
|
if (!p->via && (channel != -1)) {
|
|
if (!Strcmp(p->name,toname)) {
|
|
for (cl = p->chan_list; cl; cl = cl->next) {
|
|
if (cl->channel == channel) {
|
|
appendprompt(p, 2);
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(8),
|
|
timestamp, fromname, channel);
|
|
#else
|
|
sprintf(buffer, "%s%s made you a channel operator for channel %d\r",
|
|
timestamp, fromname, channel);
|
|
#endif
|
|
appenddirect(p, buffer);
|
|
appendprompt(p, 0);
|
|
break;
|
|
}
|
|
}
|
|
p->locked = 1;
|
|
} else {
|
|
if (p->verbose) {
|
|
appendprompt(p, 2);
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(9),
|
|
timestamp, toname, hostname, channel);
|
|
#else
|
|
sprintf(buffer, "%s%s@%s is now a channel operator for channel %d\r",
|
|
timestamp, toname, hostname, channel);
|
|
#endif
|
|
appenddirect(p, buffer);
|
|
appendprompt(p, 0);
|
|
p->locked = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
#ifndef CONVNICK
|
|
void send_persmsg(char *fromname, char *hostname, WORD channel,
|
|
#else
|
|
void send_persmsg(char *fromname, char *fromnickname, char *hostname, WORD channel,
|
|
#endif /* CONVNICK */
|
|
char *text, time_t time)
|
|
{
|
|
char buffer[2048];
|
|
char namefilt[68], *c;
|
|
register CONNECTION *p;
|
|
CHANNEL *ch;
|
|
char chan[128];
|
|
WORD mychannel;
|
|
CLIST *cl;
|
|
|
|
if (!text) /* DL1XAO NULL Pointer abfangen */
|
|
text = "";
|
|
for (ch = channels; ch; ch = ch->next) {
|
|
if (ch->chan == channel) break;
|
|
}
|
|
#ifdef SPEECH
|
|
sprintf(chan, speech_message(10), channel);
|
|
#else
|
|
sprintf(chan, "channel %d", channel);
|
|
#endif
|
|
if (ch) {
|
|
if (ch->flags & M_CHAN_S) strcpy(chan, "secret channel");
|
|
if (ch->flags & M_CHAN_I) strcpy(chan, "this invisible channel");
|
|
}
|
|
sprintf(namefilt, " %s ", fromname);
|
|
if ((c = strchr(namefilt, ':')) != NULL) {
|
|
*c++ = ' ';
|
|
*c = NUL;
|
|
}
|
|
for (p = connections; p; p = p->next) {
|
|
if (p->type == CT_HOST) {
|
|
if (!p->locked) {
|
|
#ifndef L1IRC
|
|
sprintf(buffer, "/\377\200USER %s %s %ld %d %d %s\r", fromname, hostname, (long)time, channel, channel, text);
|
|
#else
|
|
if (p->IrcMode == FALSE)
|
|
sprintf(buffer, "/\377\200USER %s %s %ld %d %d %s\r", fromname, hostname, (long)time, channel, channel, text);
|
|
else
|
|
{
|
|
sprintf(buffer, "NICK %s %d %s %s 0 + :%s", fromname, (strcasecmp(hostname, myhostname) ? 1 : 0), fromname, hostname, text);
|
|
buffer[2048] = 0;
|
|
}
|
|
#endif /* L1IRC */
|
|
appenddirect(p, buffer);
|
|
p->locked = 1;
|
|
send_proto("cvsd", "TX to %s %s", p->name, buffer+3);
|
|
}
|
|
} else {
|
|
mychannel = -1;
|
|
for (cl = p->chan_list; cl; cl = cl->next) {
|
|
if (cl->channel == channel) {
|
|
mychannel = channel;
|
|
break;
|
|
}
|
|
}
|
|
if ((p->type == CT_USER) && !p->locked && !p->via &&
|
|
(p->verbose || (mychannel == channel))) {
|
|
if (!(p->filter && strstr(p->filter, namefilt))) {
|
|
appendprompt(p, 2);
|
|
if (*text != '\0') {
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(11), timestamp, fromname, hostname, chan, text);
|
|
#else
|
|
sprintf(buffer, "%s%s@%s on %s set personal text:\r %s\r", timestamp, fromname, hostname, chan, text);
|
|
#endif
|
|
} else {
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(12), timestamp, fromname, hostname, chan);
|
|
#else
|
|
sprintf(buffer, "%s%s@%s on %s removed personal text.\r", timestamp, fromname, hostname, chan);
|
|
#endif
|
|
}
|
|
#ifdef L1IRC
|
|
if (p->IrcMode == TRUE)
|
|
{
|
|
sprintf(buffer, ":%s 311 %s %s %s %s * :%s\n"
|
|
, myhostname
|
|
, p->nickname
|
|
, fromname
|
|
, (*fromnickname ? fromnickname : fromname)
|
|
, hostname
|
|
, (*text && *text != '@') ? text : "");
|
|
buffer[2048] = 0;
|
|
}
|
|
#endif /* L1IRC */
|
|
appendstring(p, buffer);
|
|
appendprompt(p, 0);
|
|
}
|
|
}
|
|
p->locked = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
#ifndef CONVNICK
|
|
void send_topic(char *fromname, char *hostname, time_t time,
|
|
#else
|
|
void send_topic(char *fromname, char *fromnickname, char *hostname, time_t time,
|
|
#endif /* CONVNICK */
|
|
WORD channel, char *text)
|
|
{
|
|
char buffer[2048];
|
|
char namefilt[68], *c;
|
|
register CONNECTION *p;
|
|
register CHANNEL *ch;
|
|
char chan[128];
|
|
WORD mychannel, flags = 0;
|
|
CLIST *cl;
|
|
|
|
for (ch = channels; ch; ch = ch->next)
|
|
if (ch->chan == channel) break;
|
|
if (ch) {
|
|
sprintf(namefilt, " %s ", fromname);
|
|
if ((c = strchr(namefilt, ':')) != NULL) {
|
|
*c++ = ' ';
|
|
*c = NUL;
|
|
}
|
|
#ifdef SPEECH
|
|
sprintf(chan, speech_message(10), channel);
|
|
#else
|
|
sprintf(chan, "channel %d", channel);
|
|
#endif
|
|
flags = ch->flags;
|
|
if (flags & M_CHAN_S) strcpy(chan, "secret channel");
|
|
if (flags & M_CHAN_I) strcpy(chan, "this invisible channel");
|
|
#ifndef CONVTOPIC_FIX
|
|
if (ch->time < time) {
|
|
#else
|
|
if (ch->time <= time) {
|
|
#endif /* CONVTOPIC_FIX */
|
|
setstring(&(ch->topic), text, 512);
|
|
ch->time = time;
|
|
#ifdef CONV_TOPIC
|
|
/* Call sichern. */
|
|
strncpy(ch->name, fromname, NAMESIZE + 1);
|
|
/* Nullzeichen setzen. */
|
|
ch->name[sizeof(ch->name)-1] = 0;
|
|
#endif
|
|
|
|
for (p = connections; p; p = p->next) {
|
|
if (p->type == CT_HOST) {
|
|
if (!p->locked) {
|
|
#ifndef L1IRC
|
|
sprintf(buffer, "/\377\200TOPI %s %s %ld %d %s\r", fromname, hostname, (long)time, channel, text);
|
|
#else
|
|
if (p->IrcMode == FALSE)
|
|
sprintf(buffer, ":%s!%s@%s TOPIC #%d :%s\n", fromname, fromname, hostname, channel, text);
|
|
else
|
|
sprintf(buffer, "/\377\200TOPI %s %s %ld %d %s\r", fromname, hostname, (long)time, channel, text);
|
|
#endif /* L1IRC */
|
|
appenddirect(p, buffer);
|
|
p->locked = 1;
|
|
send_proto("cvsd", "TX to %s %s", p->name, buffer+3);
|
|
}
|
|
} else {
|
|
mychannel = -1;
|
|
for (cl = p->chan_list; cl; cl = cl->next) {
|
|
if (cl->channel == channel) {
|
|
mychannel = channel;
|
|
break;
|
|
}
|
|
}
|
|
if ((p->type == CT_USER) && !p->locked && !p->via &&
|
|
((!(ch->flags & M_CHAN_I) && p->verbose) || (mychannel == channel) )) {
|
|
if (!(p->filter && strstr(p->filter, namefilt))) {
|
|
appendprompt(p, 2);
|
|
if (*text != '\0')
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(13),
|
|
timestamp, fromname, hostname, chan, text);
|
|
#else
|
|
sprintf(buffer, "%s%s@%s on %s set channel topic:\r %s\r",
|
|
timestamp, fromname, hostname, chan, text);
|
|
#endif
|
|
else
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(14),
|
|
timestamp, fromname, hostname, chan);
|
|
#else
|
|
sprintf(buffer, "%s%s@%s on %s removed channel topic.\r",
|
|
timestamp, fromname, hostname, chan);
|
|
#endif
|
|
#ifdef L1IRC
|
|
if (p->IrcMode == TRUE)
|
|
{
|
|
char IrcChannel[128];
|
|
|
|
sprintf(IrcChannel, "#%d", channel);
|
|
sprintf(buffer, ":%s!%s@%s TOPIC %s :%s\n", fromname, fromname, hostname, IrcChannel, text);
|
|
}
|
|
#endif /* L1IRC */
|
|
appendstring(p, buffer);
|
|
appendprompt(p, 0);
|
|
}
|
|
}
|
|
p->locked = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef CONVNICK
|
|
/* Allen Convershosts den geaenderten Nickname mitteilen */
|
|
void send_uaddmsg(CONNECTION *cp)
|
|
{
|
|
CONNECTION *p;
|
|
char buffer[1024];
|
|
|
|
/* Nur, wenn wir auch einen Nickname haben */
|
|
if (cp->nickname[0] == '\0')
|
|
return;
|
|
|
|
for (p = connections; p; p = p->next) {
|
|
/* Ist es ein Host ? */
|
|
if (p->type == CT_HOST) {
|
|
/* Wenn keine Sperre, dann senden wir den Nickname an den Host. */
|
|
if (!p->locked) {
|
|
/* Nickname nur senden wenn der Host das Flag gesendet hat. */
|
|
if (p->features & FEATURE_NICK) {
|
|
sprintf(buffer, "/\377\200UADD %s %s %s %d %s\r", cp->name, cp->host, cp->nickname, -1, cp->pers ? cp->pers : "~~");
|
|
appenddirect(p, buffer);
|
|
send_proto("cvsd", "TX to %s %s", p->name, buffer + 3);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
#ifndef CONVNICK
|
|
void send_user_change_msg(char *name, char *host,
|
|
WORD oldchannel, WORD newchannel,
|
|
char *pers, time_t time)
|
|
#else
|
|
void send_user_change_msg(char *name, char *nick, char *host,
|
|
WORD oldchannel, WORD newchannel,
|
|
char *pers, time_t time)
|
|
#endif /* CONVNICK */
|
|
{
|
|
char buffer[2048];
|
|
CONNECTION *p;
|
|
char oldchan[24], newchan[24], name2[64 + 1], *c;
|
|
CHANNEL *ch;
|
|
WORD oldflags = 0, newflags = 0;
|
|
WORD mychannel;
|
|
CLIST *cl;
|
|
|
|
if (!pers) /* DL1XAO: NULL Pointer abfangen */
|
|
pers = "";
|
|
#ifdef SPEECH
|
|
sprintf(newchan, speech_message(10), newchannel);
|
|
sprintf(oldchan, speech_message(10), oldchannel);
|
|
#else
|
|
sprintf(newchan, "channel %d", newchannel);
|
|
sprintf(oldchan, "channel %d", oldchannel);
|
|
#endif
|
|
sprintf(name2, " %s ", name);
|
|
if ((c = strchr(name2, ':')) != NULL) {
|
|
*c++ = ' ';
|
|
*c = NUL;
|
|
}
|
|
for (ch = channels; ch; ch = ch->next)
|
|
if (ch->chan == newchannel) break;
|
|
if (ch) {
|
|
newflags = ch->flags;
|
|
if (newflags & M_CHAN_S) {
|
|
#ifdef SPEECH
|
|
strcpy(newchan, speech_message(15));
|
|
#else
|
|
strcpy(newchan, "secret channel");
|
|
#endif
|
|
}
|
|
if (newflags & M_CHAN_I) {
|
|
#ifdef SPEECH
|
|
strcpy(newchan, speech_message(16));
|
|
#else
|
|
strcpy(newchan, "this invisible channel");
|
|
#endif
|
|
}
|
|
}
|
|
for (ch = channels; ch; ch = ch->next)
|
|
if (ch->chan == oldchannel) break;
|
|
if (ch) {
|
|
oldflags = ch->flags;
|
|
if (oldflags & M_CHAN_S) {
|
|
#ifdef SPEECH
|
|
strcpy(oldchan, speech_message(15));
|
|
#else
|
|
strcpy(oldchan, "secret channel");
|
|
#endif
|
|
}
|
|
if (oldflags & M_CHAN_I) {
|
|
#ifdef SPEECH
|
|
strcpy(oldchan, speech_message(16));
|
|
#else
|
|
strcpy(oldchan, "this invisible channel");
|
|
#endif
|
|
}
|
|
}
|
|
for (p = connections; p; p = p->next) {
|
|
if (p->type == CT_USER && !p->via && !p->locked) {
|
|
mychannel = -1;
|
|
for (cl = p->chan_list; cl; cl = cl->next) {
|
|
if (cl->channel == oldchannel) {
|
|
mychannel = oldchannel;
|
|
break;
|
|
}
|
|
}
|
|
if ((newchannel == oldchannel) && (newchannel != -1)) {
|
|
if ((p->verbose && !(newflags & M_CHAN_I)) || (mychannel == newchannel)) {
|
|
if (!(p->filter && strstr(p->filter, name2))) {
|
|
appendprompt(p, 2);
|
|
#ifdef L1IRC
|
|
if (p->IrcMode == FALSE)
|
|
{
|
|
#endif /* L1IRC */
|
|
if (*pers && strcmp(pers, "@"))
|
|
#ifdef CONVNICK
|
|
{
|
|
if (*nick != NUL)
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(17), timestamp, name, nick, host, newchan, pers);
|
|
#else
|
|
sprintf(buffer, "%s%s:%s@%s on %s set personal text:\r %s\r", timestamp, name, nick, host, newchan, pers);
|
|
#endif
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(11), timestamp, name, host, newchan, pers);
|
|
#else
|
|
sprintf(buffer, "%s%s@%s on %s set personal text:\r %s\r", timestamp, name, host, newchan, pers);
|
|
#endif
|
|
}
|
|
#else
|
|
sprintf(buffer, "%s%s@%s on %s set personal text:\r %s\r", timestamp, name, host, newchan, pers);
|
|
#endif
|
|
else
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(12), timestamp, name, host, newchan);
|
|
#else
|
|
sprintf(buffer, "%s%s@%s on %s removed personal text.\r", timestamp, name, host, newchan);
|
|
#endif
|
|
#ifdef L1IRC
|
|
}
|
|
else
|
|
sprintf(buffer, ":%s 311 %s %s %s %s * :%s\n"
|
|
, myhostname
|
|
, name
|
|
, (*nick ? nick : name)
|
|
, name
|
|
, host
|
|
, (*pers && *pers != '@') ? pers : "");
|
|
#endif /* L1IRC */
|
|
appendstring(p, buffer);
|
|
appendprompt(p, 0);
|
|
}
|
|
p->locked = 1;
|
|
}
|
|
} else {
|
|
if (oldchannel >= 0) {
|
|
if ((!(oldflags & M_CHAN_I) && p->verbose) || (mychannel == oldchannel)) {
|
|
appendprompt(p, 2);
|
|
if (strlen(pers) < 2) {
|
|
#ifdef CONVNICK
|
|
if (*nick != NUL)
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(18), timestamp, name, nick, host, oldchan);
|
|
#else
|
|
sprintf(buffer, "%s%s:%s@%s left %s.\r", timestamp, name, nick, host, oldchan);
|
|
#endif
|
|
else
|
|
#endif
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(19), timestamp, name, host, oldchan);
|
|
#else
|
|
sprintf(buffer, "%s%s@%s left %s.\r", timestamp, name, host, oldchan);
|
|
#endif
|
|
} else {
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(20), timestamp, name, host, oldchan, pers);
|
|
#else
|
|
sprintf(buffer, "%s%s@%s left %s (%s).\r", timestamp, name, host, oldchan, pers);
|
|
#endif
|
|
}
|
|
#ifdef L1IRC
|
|
if (p->IrcMode == TRUE)
|
|
{
|
|
char IrcChannel[128];
|
|
|
|
sprintf(IrcChannel, "#%d", oldchannel);
|
|
sprintf(buffer, ":%s!%s@%s PART %s :%s\n"
|
|
, (*nick ? nick : name)
|
|
, name
|
|
, host
|
|
, IrcChannel
|
|
, "/leave");
|
|
}
|
|
#endif /* L1IRC */
|
|
appendstring(p, buffer);
|
|
appendprompt(p, 0);
|
|
p->locked = 1;
|
|
}
|
|
}
|
|
for (cl = p->chan_list; cl; cl = cl->next) {
|
|
if (cl->channel == newchannel) {
|
|
break;
|
|
}
|
|
}
|
|
if (newchannel >= 0) {
|
|
if ((cl) || (!(newflags & M_CHAN_I) && (p->verbose || (p->notify && strstr(p->notify, name2))))) {
|
|
appendprompt(p, 2);
|
|
#ifdef CONVNICK
|
|
if (*nick != NUL)
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(21), timestamp, name, nick,host, newchan);
|
|
#else
|
|
sprintf(buffer, "%s%s:%s@%s joined %s\r", timestamp, name, nick,host, newchan);
|
|
#endif
|
|
else
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(22), timestamp, name, host, newchan);
|
|
#else
|
|
sprintf(buffer, "%s%s@%s joined %s\r", timestamp, name, host, newchan);
|
|
#endif
|
|
#else
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(22), timestamp, name, host, newchan);
|
|
#else
|
|
sprintf(buffer, "%s%s@%s joined %s\r", timestamp, name, host, newchan);
|
|
#endif
|
|
#endif
|
|
#ifdef L1IRC
|
|
if (p->IrcMode == TRUE)
|
|
{
|
|
char IrcChannel[128];
|
|
|
|
sprintf(IrcChannel, "#%d", newchannel);
|
|
sprintf(buffer, ":%s!%s@%s JOIN :%s\n", (*nick ? nick : name), name, host, IrcChannel);
|
|
appendstring(p, buffer);
|
|
|
|
sprintf(buffer, ":%s 303 %s :\n", myhostname, p->nickname);
|
|
|
|
appendstring(p, buffer);
|
|
sprintf(buffer, ":%s MODE #%d +t\n"
|
|
, host
|
|
, newchannel);
|
|
}
|
|
#endif /* L1IRC */
|
|
appendstring(p, buffer);
|
|
if (!(p->filter && strstr(p->filter, name2))) {
|
|
if (*pers && strcmp(pers, "@")) {
|
|
#ifndef L1IRC
|
|
sprintf(buffer, " (%s)\r", pers);
|
|
appendstring(p, buffer);
|
|
#else
|
|
sprintf(buffer, " (%s)\r", pers);
|
|
|
|
if (p->IrcMode == TRUE)
|
|
sprintf(buffer, ":%s 311 %s %s %s %s * :%s\n"
|
|
, myhostname
|
|
, name
|
|
, (*nick ? nick : name)
|
|
, name
|
|
, host
|
|
, (*pers && *pers != '@') ? pers : "");
|
|
|
|
appendstring(p, buffer);
|
|
#endif /* L1IRC */
|
|
}
|
|
}
|
|
appendprompt(p, 0);
|
|
p->locked = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (p->type == CT_HOST && !p->locked) {
|
|
if (time == currtime) {
|
|
time++;
|
|
}
|
|
sprintf(buffer, "/\377\200USER %s %s %ld %d %d %s\r", name, host, (long)time, oldchannel, newchannel, pers);
|
|
appenddirect(p, buffer);
|
|
p->locked = 1;
|
|
send_proto("cvsd", "TX to %s %s", p->name, buffer+3);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
void send_msg_to_local_user(char *fromname, char *toname, char *text)
|
|
{
|
|
|
|
char buffer[2048];
|
|
CONNECTION *p;
|
|
#ifdef CONVNICK
|
|
char buf[(NAMESIZE * 2) + 2];
|
|
#endif
|
|
|
|
for (p = connections; p; p = p->next)
|
|
if (p->type == CT_USER && (!strcasecmp(p->name, toname)
|
|
#ifdef CONVERS_NICKNAME
|
|
|| !strcasecmp(p->nickname, toname)
|
|
#endif
|
|
) && !p->locked)
|
|
if (!p->via) {
|
|
if (!p->locked) {
|
|
appendprompt(p, 2);
|
|
if (strcmp(fromname, "conversd")) {
|
|
#ifndef L1IRC
|
|
sprintf(buffer, "<*%s*>:", fromname);
|
|
appendformline(p, buffer, text);
|
|
#else
|
|
if (p->IrcMode == TRUE)
|
|
{
|
|
sprintf(buffer,":%s PRIVMSG %s : %s\n", fromname, p->nickname, text);
|
|
appendstring(p, buffer);
|
|
}
|
|
else
|
|
{
|
|
sprintf(buffer, "<*%s*>:", fromname);
|
|
appendformline(p, buffer, text);
|
|
}
|
|
#endif /* L1IRC */
|
|
if (p->away && text[0] != '*') {
|
|
#ifdef CONVNICK
|
|
makeName(p, buf);
|
|
#ifdef SPEECH
|
|
sprintf(buffer,speech_message(23), timestamp, buf, p->away);
|
|
#else
|
|
sprintf(buffer,"%s%s is away: %s", timestamp, buf, p->away);
|
|
#endif /* SPEECH */
|
|
#else
|
|
#ifdef SPEECH
|
|
sprintf(buffer,speech_message(23), timestamp, p->name, p->away);
|
|
#else
|
|
sprintf(buffer,"%s%s is away: %s", timestamp, p->name, p->away);
|
|
#endif /* SPEECH */
|
|
#endif /* CONVNICK */
|
|
#ifdef L1IRC
|
|
if (p->IrcMode == TRUE)
|
|
sprintf(buffer, ":%s 301 %s %s :#%s"
|
|
, myhostname
|
|
, fromname
|
|
, toname
|
|
, p->away);
|
|
#endif /* L1IRC */
|
|
send_msg_to_local_user("conversd",fromname,buffer);
|
|
}
|
|
} else {
|
|
#ifndef L1IRC
|
|
appendstring(p, text);
|
|
appenddirect(p, "\r");
|
|
#else
|
|
if (p->IrcMode == TRUE)
|
|
{
|
|
appendstring(p, text);
|
|
appendstring(p, "\n");
|
|
}
|
|
else
|
|
{
|
|
appendstring(p, text);
|
|
appenddirect(p, "\r");
|
|
}
|
|
#endif /* L1IRC */
|
|
}
|
|
appendprompt(p, 0);
|
|
p->locked = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
void send_msg_to_user(char *fromname, char *toname, char *text)
|
|
{
|
|
|
|
char buffer[2048];
|
|
char namefilt[68], *c;
|
|
WORD filtered = 0;
|
|
CONNECTION *p;
|
|
#ifdef CONVNICK
|
|
char buf[(NAMESIZE * 2) + 2];
|
|
#endif
|
|
|
|
sprintf(namefilt, " %s ", fromname);
|
|
if ((c = strchr(namefilt, ':')) != NULL) {
|
|
*c++ = ' ';
|
|
*c = NUL;
|
|
}
|
|
for (p = connections; p; p = p->next)
|
|
if (p->type == CT_USER && (!strcasecmp(p->name, toname)
|
|
#ifdef CONVERS_NICKNAME
|
|
|| !strcasecmp(p->nickname, toname)
|
|
#endif
|
|
) && !p->locked) {
|
|
if (p->via) {
|
|
if (!p->via->locked) {
|
|
sprintf(buffer, "/\377\200UMSG %s %s %s\r", fromname, toname, text);
|
|
appenddirect(p->via, buffer);
|
|
p->via->locked = 1;
|
|
p->locked = 1;
|
|
send_proto("cvsd", "TX to %s %s", p->via->name, buffer+3);
|
|
}
|
|
} else {
|
|
if (!p->locked) {
|
|
if (p->filter && strstr(p->filter, namefilt)) {
|
|
filtered = 1;
|
|
continue;
|
|
}
|
|
appendprompt(p, 2);
|
|
if (strcmp(fromname, "conversd")) {
|
|
#ifndef L1IRC
|
|
sprintf(buffer, "<*%s*>:", fromname);
|
|
appendformline(p, buffer, text);
|
|
#else
|
|
if (p->IrcMode == TRUE)
|
|
{
|
|
if ((c = strchr(fromname, ':')) != NULL)
|
|
c++;
|
|
|
|
sprintf(buffer,":%s PRIVMSG %s : %s\n"
|
|
, (c[0] == FALSE ? fromname : c)
|
|
, p->nickname, text);
|
|
appendstring(p, buffer);
|
|
}
|
|
else
|
|
{
|
|
sprintf(buffer, "<*%s*>:", fromname);
|
|
appendformline(p, buffer, text);
|
|
}
|
|
#endif /* L1IRC */
|
|
if (p->away && text[0] != '*') {
|
|
#ifdef CONVNICK
|
|
makeName(p, buf);
|
|
#ifdef SPEECH
|
|
sprintf(buffer,speech_message(23), timestamp, buf, p->away);
|
|
#else
|
|
sprintf(buffer,"%s%s is away: %s", timestamp, buf, p->away);
|
|
#endif /* SPEECH */
|
|
#else
|
|
#ifdef SPEECH
|
|
sprintf(buffer,speech_message(23), timestamp, p->name, p->away);
|
|
#else
|
|
sprintf(buffer,"%s%s is away: %s", timestamp, p->name, p->away);
|
|
#endif /* SPEECH */
|
|
#endif /* CONVNICK */
|
|
#ifdef L1IRC
|
|
if (p->IrcMode == TRUE)
|
|
sprintf(buffer, ":%s 301 %s %s :#%s\n"
|
|
,p->host
|
|
,p->nickname
|
|
,p->name
|
|
,p->away);
|
|
#endif /* L1IRC */
|
|
send_msg_to_local_user("conversd",fromname,buffer);
|
|
}
|
|
} else {
|
|
#ifndef L1IRC
|
|
appendstring(p, text);
|
|
appenddirect(p, "\r");
|
|
#else
|
|
if (p->IrcMode == TRUE)
|
|
{
|
|
appendstring(p, text);
|
|
appendstring(p, "\n");
|
|
}
|
|
else
|
|
{
|
|
appendstring(p, text);
|
|
appenddirect(p, "\r");
|
|
}
|
|
#endif /* L1IRC */
|
|
}
|
|
appendprompt(p, 0);
|
|
p->locked = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (filtered) {
|
|
clear_locks();
|
|
#ifdef SPEECH
|
|
sprintf(buffer,speech_message(24), timestamp, toname);
|
|
#else
|
|
sprintf(buffer,"%sYour messages are ignored by %s", timestamp, toname);
|
|
#endif
|
|
#ifdef L1IRC
|
|
if (p->IrcMode == TRUE)
|
|
sprintf(buffer,":%s 465 %s :Nachricht wird gefiltert!\n"
|
|
, p->host
|
|
, (p->nickname ? p->nickname : p->name));
|
|
#endif /* L1IRC */
|
|
send_msg_to_user("conversd",fromname,buffer);
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
void send_msg_to_channel(char *fromname, WORD channel, char *text)
|
|
{
|
|
char buffer[2048];
|
|
char namefilt[68], *c;
|
|
CONNECTION *p;
|
|
CHANNEL *ch;
|
|
char addchan[16];
|
|
CLIST *cl;
|
|
WORD printit;
|
|
WORD cvd;
|
|
#ifdef CONVNICK
|
|
char Nickname[NAMESIZE + 1];
|
|
#endif /* CONVNICK */
|
|
|
|
cvd = strcmp(fromname, "conversd");
|
|
if (!cvd && !strncmp(text, "*** ", 4)) { /* /me abfangen */
|
|
sscanf(text + 4, "%s", buffer); /* Absender ermitteln */
|
|
buffer[64] = '\0';
|
|
if ((c = strchr(buffer, '@')) != NULL)
|
|
*c = '\0';
|
|
sprintf(namefilt, " %s ", buffer);
|
|
#ifdef CONVNICK
|
|
memset(Nickname, 0, sizeof(Nickname)); /* String Initialisieren. */
|
|
|
|
if ((c = strchr(buffer, ':')) != NULL) /* ggf. Nickname ermitteln. */
|
|
{
|
|
c++; /* ':' zeichen loeschen. */
|
|
strncpy(Nickname, c, NAMESIZE); /* Nickname sichern. */
|
|
}
|
|
#endif /* CONVNICK */
|
|
} else {
|
|
sprintf(namefilt, " %s ", fromname);
|
|
if ((c = strchr(namefilt, ':')) != NULL) {
|
|
*c++ = ' ';
|
|
*c = NUL;
|
|
}
|
|
}
|
|
for (ch = channels; ch; ch = ch->next) {
|
|
if (ch->chan == channel) break;
|
|
}
|
|
for (p = connections; p; p = p->next) {
|
|
#ifdef CONVNICK
|
|
/* Wir pruefen auf Rufzeichen *und* Nickname */
|
|
if (p->type == CT_USER && (!strcasecmp(p->name, fromname) || !strcasecmp(p->nickname, fromname))) {
|
|
#else
|
|
if (p->type == CT_USER && !Strcmp(p->name, fromname)) {
|
|
#endif
|
|
p->mtime = currtime;
|
|
}
|
|
}
|
|
for (p = connections; p; p = p->next) {
|
|
if (p->type == CT_USER) {
|
|
printit = 0;
|
|
if (p->channel == channel) {
|
|
printit = 1;
|
|
addchan[0] = '\0';
|
|
} else {
|
|
for (cl = p->chan_list; cl ; cl = cl->next) {
|
|
if (cl->channel == channel) {
|
|
printit = 1;
|
|
sprintf(addchan, "%d:", channel);
|
|
}
|
|
}
|
|
}
|
|
if (printit) {
|
|
if (p->via) {
|
|
if (!p->via->locked && !(ch->flags & M_CHAN_L)) {
|
|
sprintf(buffer, "/\377\200CMSG %s %d %s\r", fromname, channel, text);
|
|
appenddirect(p->via, buffer);
|
|
p->via->locked = 1;
|
|
}
|
|
} else {
|
|
if (!p->locked) {
|
|
if (p->filter && strstr(p->filter, namefilt))
|
|
continue;
|
|
appendprompt(p, 2);
|
|
if (cvd) {
|
|
#ifndef L1IRC
|
|
sprintf(buffer, "<%s%s>:", addchan, fromname);
|
|
appendformline(p, buffer, text);
|
|
#else
|
|
if (p->IrcMode == TRUE)
|
|
{
|
|
sprintf(buffer, ":%s PRIVMSG #%d :%s\n",fromname, channel, text);
|
|
appendstring(p, buffer);
|
|
}
|
|
else
|
|
{
|
|
sprintf(buffer, "<%s%s>", addchan, fromname);
|
|
appendformline(p, buffer, text);
|
|
}
|
|
#endif /* L1IRC */
|
|
} else {
|
|
#ifndef L1IRC
|
|
appendstring(p, text);
|
|
appenddirect(p, "\r");
|
|
#else
|
|
if (p->IrcMode == TRUE) /* IRC-Client. */
|
|
{
|
|
char buffer2[2048];
|
|
/* IRC-Meldung vorbereiten. */
|
|
sprintf(buffer2, ":%s PRIVMSG #%d :%s\n"
|
|
, (Nickname[0] != FALSE ? Nickname : buffer)
|
|
, channel
|
|
, text);
|
|
appendstring(p, buffer2); /* IRC-Meldung senden. */
|
|
}
|
|
else
|
|
{
|
|
appendstring(p, text);
|
|
appenddirect(p, "\r");
|
|
}
|
|
#endif /* L1IRC */
|
|
}
|
|
appendprompt(p, 0);
|
|
p->locked = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* DL1XAO Protokollausgabe, lokal auf Kanal 32767, egal welchen Status
|
|
* er sonst noch hat
|
|
*/
|
|
void send_proto(const char *modul, const char *format, ...)
|
|
{
|
|
char buffer[16];
|
|
CONNECTION *p;
|
|
CHANNEL *ch;
|
|
CLIST *cl;
|
|
WORD printit;
|
|
va_list arg_ptr;
|
|
char str[1024];
|
|
|
|
va_start(arg_ptr, format);
|
|
vsprintf(str, format, arg_ptr);
|
|
va_end(arg_ptr);
|
|
|
|
if (!cvs_pc)
|
|
return;
|
|
for (ch = channels; ch; ch = ch->next)
|
|
if (ch->chan == 32767)
|
|
break;
|
|
if (!ch) /* nobody online */
|
|
return;
|
|
|
|
for (p = connections; p; p = p->next) {
|
|
if (p->type == CT_USER && !p->via) {
|
|
printit = 0;
|
|
if (p->channel == 32767)
|
|
printit = 1;
|
|
else {
|
|
for (cl = p->chan_list; cl ; cl = cl->next)
|
|
if (cl->channel == 32767)
|
|
printit = 1;
|
|
}
|
|
if (printit) {
|
|
appendprompt(p, 2);
|
|
sprintf(buffer, "[%s]:", modul);
|
|
appendformline(p, buffer, str);
|
|
appendprompt(p, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
void send_invite_msg(char *fromname, char *toname, WORD channel)
|
|
{
|
|
CONNECTION *p;
|
|
char buffer[2048];
|
|
#ifdef SPEECH
|
|
static char invitetext[128];
|
|
static char responsetext[128];
|
|
|
|
strcpy(invitetext,speech_message(25));
|
|
strcpy(responsetext,speech_message(26));
|
|
#else
|
|
static char invitetext[] = "\r\007\007%sMessage from %s...\rPlease join %s channel %d.\r\007\007\r";
|
|
static char responsetext[] = "%s%s Invitation sent to %s @ %s.";
|
|
#endif
|
|
|
|
|
|
for (p = connections; p; p = p->next)
|
|
if (p->type == CT_USER && !Strcmp(p->name, toname)) {
|
|
if (p->channel == channel) {
|
|
clear_locks();
|
|
#ifdef SPEECH
|
|
sprintf(buffer, speech_message(27), timestamp, toname);
|
|
#else
|
|
sprintf(buffer, "%sUser %s is already on this channel.", timestamp, toname);
|
|
#endif
|
|
send_msg_to_user("conversd", fromname, buffer);
|
|
return;
|
|
}
|
|
if (!p->via && !p->locked) {
|
|
sprintf(buffer, invitetext, timestamp, fromname, convtype, channel);
|
|
p->invitation_channel = channel;
|
|
appendstring(p, buffer);
|
|
clear_locks();
|
|
sprintf(buffer, responsetext, timestamp, convtype, toname, myhostname);
|
|
send_msg_to_user("conversd", fromname, buffer);
|
|
return;
|
|
}
|
|
if (p->via && !p->via->locked) {
|
|
sprintf(buffer, "/\377\200INVI %s %s %d\r", fromname, toname, channel);
|
|
appenddirect(p->via, buffer);
|
|
send_proto("cvsd", "TX to %s %s", p->via->name, buffer+3);
|
|
return;
|
|
}
|
|
}
|
|
|
|
sprintf(buffer, invitetext, timestamp, fromname, convtype, channel);
|
|
if (invite_ccp(toname, buffer)) {
|
|
clear_locks();
|
|
sprintf(buffer, responsetext, timestamp, convtype, toname, myhostname);
|
|
send_msg_to_user("conversd", fromname, buffer);
|
|
return;
|
|
}
|
|
|
|
for (p = connections; p; p = p->next)
|
|
if (p->type == CT_HOST && !p->locked) {
|
|
sprintf(buffer, "/\377\200INVI %s %s %d\r", fromname, toname, channel);
|
|
appenddirect(p, buffer);
|
|
send_proto("cvsd", "TX to %s %s", p->name, buffer+3);
|
|
}
|
|
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
void update_destinations(PERMLINK *p, char *name, time_t rtt, char *rev)
|
|
{
|
|
PERMLINK *l;
|
|
DESTINATION *d, *d1;
|
|
WORD pl;
|
|
char buffer[256];
|
|
|
|
for (d = destinations; d; d = d->next)
|
|
if (!Strcmp(d->name, name)) break;
|
|
|
|
if (!d) {
|
|
d = (DESTINATION *)calloc(1, sizeof(DESTINATION));
|
|
if (d) {
|
|
d->link = p;
|
|
Strcpy(d->name, name);
|
|
Strcpy(d->rev, rev);
|
|
if (!destinations || (! destinations->name) || (Strcmp(destinations->name, name) > 0)) {
|
|
d->next = destinations;
|
|
destinations = d;
|
|
} else {
|
|
d1 = destinations;
|
|
while (d1->next) {
|
|
if (Strcmp(d1->next->name, name) > 0) {
|
|
d->next = d1->next;
|
|
d1->next = d;
|
|
break;
|
|
}
|
|
d1 = d1->next;
|
|
}
|
|
if (!d1->next) {
|
|
d->next = d1->next;
|
|
d1->next = d;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
Strcpy(d->rev, rev);
|
|
d->link = p;
|
|
}
|
|
|
|
if (!d)
|
|
return;
|
|
|
|
d->rtt = rtt;
|
|
if (labs(rtt - d->last_sent_rtt) > (d->last_sent_rtt / 8L)) {
|
|
for (pl = 0; pl < MAXCVSHOST; pl++) {
|
|
l = permarray[pl];
|
|
if ( l != NULL
|
|
&& l != d->link
|
|
&& l->connection
|
|
&& l->connection->type == CT_HOST
|
|
) {
|
|
if (rtt)
|
|
sprintf(buffer, "/\377\200DEST %s %ld %s\r", name, rtt+(l->txtime+l->rxtime)/2L, rev);
|
|
else
|
|
sprintf(buffer, "/\377\200DEST %s 0\r", name);
|
|
|
|
d->last_sent_rtt = rtt;
|
|
appenddirect(l->connection, buffer);
|
|
send_proto("cvsd", "TX to %s %s", l->connection->name, buffer+3);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
#if !defined(__WIN32__) && !defined(__LINUX__)
|
|
#pragma warn -par
|
|
#endif
|
|
PERMLINK *update_permlinks(char *name, CONNECTION *cp, WORD isperm)
|
|
{
|
|
DESTINATION *d;
|
|
PERMLINK *p;
|
|
WORD pl;
|
|
#ifdef CONVERS_LINKS
|
|
char NAME[NAMESIZE + 1];
|
|
#endif
|
|
|
|
if (*name == NUL)
|
|
return(NULLPERMLINK);
|
|
|
|
#ifdef CONVERS_LINKS
|
|
strncpy(NAME, name, NAMESIZE);
|
|
strupr(NAME);
|
|
#endif
|
|
|
|
for (pl = 0; pl < MAXCVSHOST; pl++) {
|
|
p = permarray[pl];
|
|
if (p == NUL)
|
|
continue;
|
|
#ifdef CONVERS_LINKS
|
|
if ((cmpcal(p->call,NAME)) || (!strcasecmp(p->cname, name)))
|
|
#else
|
|
if (!strcmp(p->cname, name))
|
|
#endif
|
|
{ /* Eintrag gefunden,aendern */
|
|
for (d = destinations; d; d = d->next) {
|
|
if (d->rtt && (d->link == p)) {
|
|
update_destinations(p, d->name, 0, "");
|
|
}
|
|
}
|
|
if (cp) { /* eintragen */
|
|
p->connection = cp;
|
|
p->statetime = currtime;
|
|
p->tries = 0;
|
|
p->waittime = 9;
|
|
p->rxtime = 0;
|
|
p->txtime = 0;
|
|
p->testwaittime = currtime;
|
|
p->testnexttime = currtime + 60;
|
|
p->retrytime = currtime + p->waittime;
|
|
} else { /* austragen */
|
|
p->statetime = currtime;
|
|
p->tries = 0;
|
|
if (p->locked) {
|
|
p->waittime = 3600;
|
|
p->nlcks++;
|
|
}
|
|
else
|
|
p->waittime = 9;
|
|
p->rxtime = 0;
|
|
p->txtime = 0;
|
|
p->testwaittime = currtime;
|
|
p->testnexttime = currtime + 60;
|
|
p->retrytime = currtime + p->waittime;
|
|
}
|
|
return(p);
|
|
}
|
|
}
|
|
for (pl = 0; pl < MAXCVSHOST; pl++) { /* neuer Eintrag */
|
|
if (!permarray[pl]) break;
|
|
}
|
|
if (pl < MAXCVSHOST) {
|
|
p = (PERMLINK *) calloc(1, sizeof(PERMLINK));
|
|
if (p) {
|
|
strncpy(p->cname, name, NAMESIZE);
|
|
strcpy(p->call, name);
|
|
p->connection = cp;
|
|
p->statetime = currtime;
|
|
p->waittime = 9;
|
|
p->testnexttime = currtime + 60;
|
|
p->testwaittime = currtime;
|
|
p->retrytime = currtime + p->waittime;
|
|
}
|
|
permarray[pl] = p;
|
|
} else {
|
|
return(NULLPERMLINK);
|
|
}
|
|
return(p);
|
|
}
|
|
#if !defined(__WIN32__) && !defined(__LINUX__)
|
|
#pragma warn .par
|
|
#endif
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
void connect_permlinks()
|
|
{
|
|
|
|
#define MAX_WAITTIME (60L*60L*3L)
|
|
|
|
WORD pl;
|
|
PERMLINK *p;
|
|
DESTINATION *d;
|
|
|
|
for (pl = 0; pl < MAXCVSHOST; pl++) {
|
|
p = permarray[pl];
|
|
if (p && p->connection && p->connection->type == CT_HOST) {
|
|
if (p->testnexttime < currtime) {
|
|
if ((p->testwaittime + 7300L) < currtime) {
|
|
p->rxtime = 0;
|
|
p->txtime = 0;
|
|
for (d = destinations; d; d = d->next) {
|
|
if (d->link == p) {
|
|
update_destinations(p, d->name, 0, "");
|
|
}
|
|
}
|
|
}
|
|
appenddirect(p->connection, "/\377\200PING\r");
|
|
send_proto("cvsd", "TX to %s PING", p->cname);
|
|
p->testwaittime = currtime;
|
|
p->testnexttime = currtime + 7300L;
|
|
}
|
|
}
|
|
}
|
|
for (pl = 0; pl < MAXCVSHOST; pl++) {
|
|
p = permarray[pl];
|
|
if (p && !p->connection) {
|
|
if (p->retrytime < currtime) {
|
|
p->tries++;
|
|
if (p->locked) { /* Sperrzeit abgelaufen */
|
|
p->waittime = 75;
|
|
p->locked = 0;
|
|
}
|
|
if (p->waittime == 9) p->waittime = 75; /* *2 = 2.5 minutes */
|
|
p->waittime <<= 1; /* 2.5,5,10,20,40,80,160,180,180,... min */
|
|
if (p->waittime > MAX_WAITTIME) p->waittime = MAX_WAITTIME;
|
|
p->retrytime = currtime + p->waittime;
|
|
if (p->port != 254)
|
|
connect_cvshost(p);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
/* lokal eingegebene Personalbeschreibungen werden in einer Datenbank
|
|
* gespeichert. Deim Einloggen von bekannten Personen wird der Text
|
|
* automatisch gesetzt. Die Datenbank laeuft im textpath (ramdisk), die
|
|
* Daten koennen im confpath gesichert werden. Die Textlaenge wird auf
|
|
* 118 Zeichen begrenzt, das sollte ausreichen.
|
|
* Zusaetzlich werden die Zeilenbreite, sowie Zeichensaetze gespeichert
|
|
* und ein Timestamp, der zum Loeschen von VOM's dient.
|
|
*/
|
|
char *personalmanager(WORD func, CONNECTION *cp, char *pers)
|
|
{
|
|
char buffer[1024];
|
|
static char tmp[128];
|
|
ULONG n;
|
|
FILE *fp1;
|
|
#ifndef MC68302
|
|
FILE *fp2;
|
|
#endif
|
|
|
|
if (cp && *cp->name) {
|
|
sprintf(tmp, "%-6.6s", cp->name);
|
|
strupr(tmp);
|
|
}
|
|
else
|
|
cp = NULL;
|
|
switch (func) {
|
|
case INIT:
|
|
persfile = strdup(pers);
|
|
#ifndef MC68302
|
|
strcpy(tmp, confpath);
|
|
strcat(tmp, "convers.prs");
|
|
if (!stricmp(persfile, tmp)) /* Pfade sind gleich */
|
|
break;
|
|
if ((fp1 = xfopen(tmp, "rb")) == NULL) /* noch keine Datei */
|
|
break;
|
|
if ((fp2 = xfopen(persfile, "wb")) == NULL) { /*Schreibfehler*/
|
|
fclose(fp1);
|
|
break;
|
|
} /* Daten umkopieren */
|
|
while ((n = fread(buffer, 1, 1024, fp1)) > 0)
|
|
fwrite(buffer, 1, (size_t)n, fp2);
|
|
fclose(fp1);
|
|
fclose(fp2);
|
|
#endif
|
|
break;
|
|
|
|
case SAVE:
|
|
#ifndef MC68302
|
|
strcpy(tmp, confpath);
|
|
strcat(tmp, "convers.prs");
|
|
if (!stricmp(persfile, tmp)) /* Pfade sind gleich */
|
|
break;
|
|
if ((fp1 = xfopen(persfile, "rb")) == NULL)/*noch keine Datei*/
|
|
break;
|
|
if ((fp2 = xfopen(tmp, "wb")) == NULL) { /* Schreibfehler */
|
|
fclose(fp1);
|
|
break;
|
|
} /* Daten umkopieren */
|
|
while ((n = fread(buffer, 1, 1024, fp1)) > 0)
|
|
fwrite(buffer, 1, (size_t)n, fp2);
|
|
fclose(fp1);
|
|
fclose(fp2);
|
|
#endif
|
|
break;
|
|
|
|
case SET:
|
|
if (!cp || !pers)
|
|
break;
|
|
strncpy(tmp+6, pers, 118);
|
|
tmp[124] = (char)(currtime >> 24); /* Timestamp, ca 194 Tage */
|
|
tmp[125] = (char)cp->width;
|
|
tmp[126] = (char)cp->charset_in;
|
|
tmp[127] = (char)cp->charset_out;
|
|
if ((fp1 = xfopen(persfile, "rb+")) == NULL) {/*Datei oeffnen*/
|
|
if ((fp1 = xfopen(persfile, "wb")) != NULL) { /* dann neu */
|
|
fwrite(tmp, 1, 128, fp1); /* der erste Eintrag */
|
|
fclose(fp1);
|
|
}
|
|
break;
|
|
}
|
|
func = 0;
|
|
n = 0;
|
|
while (!func && fread(buffer, 1, 128, fp1)) {/* suchen */
|
|
if (!strncmp(buffer, tmp, 6)) {
|
|
func = 1;
|
|
break;
|
|
}
|
|
n += 128;
|
|
}
|
|
if (func) /* zum editieren zu- */
|
|
fseek(fp1, n, SEEK_SET); /* rueckpositionieren */
|
|
fwrite(tmp, 1, 128, fp1); /* Daten schreiben */
|
|
fclose(fp1);
|
|
break;
|
|
|
|
case GET:
|
|
if (!cp)
|
|
break;
|
|
if ((fp1 = xfopen(persfile, "rb+")) == NULL)
|
|
break;
|
|
n = 0;
|
|
while (fread(buffer, 1, 128, fp1)) {
|
|
if (!strncmp(buffer, tmp, 6)) { /* suchen */
|
|
if (buffer[124] != (char)(currtime >> 24)) { /* neuen */
|
|
buffer[124] = (char)(currtime >> 24); /* Timestamp */
|
|
fseek(fp1, n, SEEK_SET); /*rueckpositionieren*/
|
|
fwrite(buffer, 1, 128, fp1); /* Daten schreiben */
|
|
}
|
|
fclose(fp1);
|
|
if ((cp->width = buffer[125]) == 0)
|
|
cp->width = 80;
|
|
cp->charset_in = buffer[126];
|
|
cp->charset_out = buffer[127];
|
|
buffer[124] = '\0';
|
|
strcpy(tmp, buffer+6);
|
|
return(tmp); /* zurueckgeben */
|
|
}
|
|
n += 128;
|
|
}
|
|
fclose(fp1);
|
|
}
|
|
return(NULL);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
char *getflags(WORD flag)
|
|
{
|
|
static char f[8];
|
|
char *p;
|
|
|
|
p = f;
|
|
if (flag & M_CHAN_S)
|
|
*p++ = 'S';
|
|
if (flag & M_CHAN_P)
|
|
*p++ = 'P';
|
|
if (flag & M_CHAN_T)
|
|
*p++ = 'T';
|
|
if (flag & M_CHAN_I)
|
|
*p++ = 'I';
|
|
if (flag & M_CHAN_M)
|
|
*p++ = 'M';
|
|
if (flag & M_CHAN_L)
|
|
*p++ = 'L';
|
|
*p = '\0';
|
|
return(f);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
/* aehnlich strncpy, speziell zum Eintragen in die Namensfelder */
|
|
void Strcpy(char *dst, char *src)
|
|
{
|
|
WORD max;
|
|
|
|
for (max = NAMESIZE-1; max-- && *src; )
|
|
*dst++ = *src++;
|
|
*dst = '\0';
|
|
}
|
|
|
|
/* aehnlich strncmp, prueft mit auf Namensfeldbreite gekuerztem b */
|
|
WORD Strcmp(char *a, char *b)
|
|
{
|
|
char tmp[NAMESIZE];
|
|
|
|
Strcpy(tmp, b);
|
|
return(strcmp(a, tmp));
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
/* Da einige Felder zuviel Platz belegen und es einfach Verschwendung
|
|
ist, dafuer soviel Platz zu belegen, obwohl man diese nicht immer
|
|
nutzt, verwalten wir das ganze mit Pointern und dynamisch.
|
|
Einige andere Funktionen mussten diesem Verhalten angepasst werden.
|
|
|
|
Eingabe:
|
|
adr : Zeiger auf den Zeiger auf den String
|
|
str : neuer String, leer zum Loeschen
|
|
max : maximale ehemalige Feldbreite
|
|
Resultat:
|
|
Ueber adr wird der Zeiger in der Struktur modifiziert */
|
|
|
|
void setstring(char **adr, char *str, WORD max)
|
|
{
|
|
if (!*str) { /* Kein String,also loeschen */
|
|
if (*adr) /* schon ein String gesetzt, */
|
|
free(*adr); /* also Speicher freigeben */
|
|
*adr = NULL; /* markieren */
|
|
}
|
|
else {
|
|
#ifdef __WIN32__
|
|
if (strlen(str) >= (unsigned short)max) /* String zulang, */
|
|
#else
|
|
if (strlen(str) >= max) /* String zulang, */
|
|
#endif /* WIN32 */
|
|
*(str + max-1) = '\0'; /* also kuerzen */
|
|
if (*adr) { /* schon ein String gesetzt, */
|
|
if (!strcmp(*adr, str)) /* String ist derselbe */
|
|
return; /* also nichts zutun */
|
|
free(*adr); /* Speicher freigeben */
|
|
}
|
|
*adr = strdup(str); /* neuen String einfuegen */
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
#ifdef CONV_CHECK_USER
|
|
/************************************************************************/
|
|
/* Pruefung auf Doppel-Login */
|
|
/*----------------------------------------------------------------------*/
|
|
CONNECTION *CheckUserCVS(char *user)
|
|
{
|
|
CONNECTION *p;
|
|
|
|
for (p = connections; p; p = p->next)
|
|
{
|
|
if ( ((!strcasecmp(p->name, user)) /* Rufzeichenvergleich. */
|
|
#ifdef CONVNICK
|
|
||(!strcasecmp(p->nickname, user)) /* Nicknamevergleich. */
|
|
#endif /* CONVNICK */
|
|
)
|
|
&&(p->type == CT_USER)) /* Als User markiert. */
|
|
return (p);
|
|
}
|
|
|
|
return(NULL);
|
|
}
|
|
#endif /* CONV_CHECK_USER. */
|
|
|
|
#else
|
|
#if !defined(__WIN32__) && !defined(__LINUX__)
|
|
#pragma warn -par
|
|
#endif
|
|
|
|
void send_proto(const char *modul, const char *format, ...)
|
|
{
|
|
}
|
|
|
|
char *personalmanager(WORD func, CONNECTION *cp, char *pers)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
#if !defined(__WIN32__) && !defined(__LINUX__)
|
|
#pragma warn .par
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef BEACON_STATUS
|
|
char *convers_user(char *cuser)
|
|
{
|
|
WORD newchannel;
|
|
WORD printit;
|
|
|
|
newchannel = 0;
|
|
#ifdef PPCONVERS
|
|
printit = count_user(newchannel);
|
|
sprintf(cuser,"%u",printit);
|
|
#else
|
|
printit = FALSE;
|
|
#endif
|
|
return(cuser);
|
|
}
|
|
#endif
|
|
|
|
/* End of $RCSfile$ */
|