733 lines
18 KiB
C
733 lines
18 KiB
C
/* $Id: server.c,v 1.2 1997/04/03 22:34:51 luethje Exp $
|
|
*
|
|
* ISDN accounting for isdn4linux.
|
|
*
|
|
* Copyright 1996 by Stefan Luethje (luethje@sl-gw.lake.de)
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
* $Log: server.c,v $
|
|
* Revision 1.2 1997/04/03 22:34:51 luethje
|
|
* splitt the files callerid.conf and ~/.isdn.
|
|
*
|
|
*/
|
|
|
|
/****************************************************************************/
|
|
|
|
#define _SERVER_C_
|
|
|
|
/****************************************************************************/
|
|
|
|
#include "isdnlog.h"
|
|
|
|
/****************************************************************************/
|
|
|
|
static char **Old_Prints = NULL;
|
|
static char **Old_Info = NULL;
|
|
static char **Cur_Info = NULL;
|
|
static int Cur_Info_Size = 0;
|
|
|
|
/****************************************************************************/
|
|
|
|
static int new_client(int sock);
|
|
static int del_Cur_Info(int channel);
|
|
static int add_Cur_Info(int channel, char *String);
|
|
static int append_Old_Info(char *String);
|
|
static char *Get_Address(char *Number);
|
|
static int Set_Address(char *String);
|
|
static int Write_Caller_Message(int sock, CALL *info);
|
|
static char *Build_Call_Info(CALL *call, int chan);
|
|
static int save_messages(char *String, int channel, int stat);
|
|
static int broadcast_from_server(char* Num, int Flag, int Message, char *String);
|
|
static int append_Old_Prints(char *String);
|
|
static int String_For_Output(char *String);
|
|
|
|
/****************************************************************************/
|
|
|
|
extern time_t cur_time;
|
|
|
|
/****************************************************************************/
|
|
|
|
int listening(int port)
|
|
{
|
|
int sock;
|
|
struct servent *sp = NULL;
|
|
|
|
|
|
if ((sock = server_connect(&sp,port)) < 0)
|
|
{
|
|
if (sock == NO_SOCKET)
|
|
{
|
|
print_msg(PRT_NORMAL,"Can not open socket %d: %s\n",sock,strerror(errno));
|
|
}
|
|
else
|
|
if (sock == NO_BIND)
|
|
{
|
|
print_msg(PRT_NORMAL,"Can not bind socket: %s\n",strerror(errno));
|
|
}
|
|
else
|
|
if (sock == NO_LISTEN)
|
|
{
|
|
print_msg(PRT_NORMAL,"Can not start listening: %s\n",strerror(errno));
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
if (sp)
|
|
{
|
|
print_msg(PRT_DEBUG_CS,"Got service %s on port %d\n",
|
|
sp->s_name,ntohs(sp->s_port));
|
|
}
|
|
else
|
|
{
|
|
print_msg(PRT_DEBUG_CS,"Got port %d\n", port);
|
|
}
|
|
|
|
return sock;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int new_client(int sock)
|
|
{
|
|
int Accept;
|
|
int Cnt;
|
|
int RetCode;
|
|
char *Host = NULL;
|
|
static CALL *Info = NULL;
|
|
|
|
|
|
if ((RetCode = read_user_access()) != 0)
|
|
{
|
|
print_msg(PRT_ERR,"Error while reading file \"%s\"!\n",userfile());
|
|
Exit(24);
|
|
}
|
|
|
|
sockets[sock].f_username = (char*) calloc(strlen(sockets[sock].msgbuf.buf)+1,
|
|
sizeof(char));
|
|
strcpy(sockets[sock].f_username,sockets[sock].msgbuf.buf);
|
|
|
|
Accept = user_has_access(sockets[sock].f_username,sockets[sock].f_hostname);
|
|
|
|
|
|
sockets[sock].msg = MSG_VERSION;
|
|
msgcpy(&(sockets[sock]),PROT_VERSION,strlen(PROT_VERSION)+1);
|
|
|
|
if (Write(&(sockets[sock])) < 1)
|
|
{
|
|
disconnect_client(sock);
|
|
return 0;
|
|
}
|
|
|
|
Host = sockets[sock].f_hostname != NULL ? sockets[sock].f_hostname : "unknown";
|
|
print_msg(PRT_DEBUG_CS,"connection from client %s@%s %s\n",
|
|
sockets[sock].f_username,
|
|
Host,
|
|
Accept != -1?"accepted":"rejected");
|
|
|
|
if (Accept == -1)
|
|
{ /* Ablehnung der Verbindung */
|
|
sockets[sock].waitstatus = WF_CLOSE;
|
|
sockets[sock].msg = MSG_ANN_REJ;
|
|
sockets[sock].msgbuf.used = 0;
|
|
|
|
Write(&(sockets[sock]));
|
|
|
|
/* Die naechste Zeile wird nicht gebraucht
|
|
disconnect_client(sock);
|
|
*/
|
|
return 0;
|
|
}
|
|
else
|
|
{ /* Verbindung wird angenommen */
|
|
sockets[sock].msg = MSG_ANN_ACC;
|
|
msgcpy(&(sockets[sock]),itos(Accept,_MSG_2B),_MSG_2B+1);
|
|
|
|
if (Write(&(sockets[sock])) < 1)
|
|
{
|
|
disconnect_client(sock);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
sockets[sock].waitstatus = WF_NOTHING;
|
|
|
|
if (Old_Info != NULL)
|
|
for (Cnt = 0; Cnt < mcalls; Cnt++)
|
|
if (Old_Info[Cnt] != NULL &&
|
|
Set_Info_Struct(&Info,Old_Info[Cnt]) >= 0 &&
|
|
User_Get_Message(sockets[sock].f_username,sockets[sock].f_hostname,Info->num[_ME(Info)],0) == 0)
|
|
{
|
|
sockets[sock].msg = MSG_CALL_INFO;
|
|
msgcpy(&(sockets[sock]),Old_Info[Cnt],strlen(Old_Info[Cnt])+1);
|
|
|
|
if (Write(&(sockets[sock])) < 1)
|
|
{
|
|
disconnect_client(sock);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (Cur_Info != NULL)
|
|
for (Cnt = 0; Cnt < Cur_Info_Size; Cnt++)
|
|
if (Cur_Info[Cnt] != NULL &&
|
|
Set_Info_Struct(&Info,Cur_Info[Cnt]) >= 0 &&
|
|
User_Get_Message(sockets[sock].f_username,sockets[sock].f_hostname,Info->num[_ME(Info)],0) == 0)
|
|
{
|
|
sockets[sock].msg = MSG_CALL_INFO;
|
|
msgcpy(&(sockets[sock]),Cur_Info[Cnt],strlen(Cur_Info[Cnt])+1);
|
|
|
|
if (Write(&(sockets[sock])) < 1)
|
|
{
|
|
disconnect_client(sock);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (Old_Prints != NULL && User_Get_Message(sockets[sock].f_username,sockets[sock].f_hostname,NULL,T_PROTOCOL) == 0)
|
|
for (Cnt = 0; Cnt < xlog; Cnt++)
|
|
if (Old_Prints[Cnt] != NULL)
|
|
{
|
|
sockets[sock].msg = MSG_SERVER;
|
|
msgcpy(&(sockets[sock]),Old_Prints[Cnt],strlen(Old_Prints[Cnt])+1);
|
|
|
|
if (Write(&(sockets[sock])) < 1)
|
|
{
|
|
disconnect_client(sock);
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
break;
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int disconnect_client(int sock)
|
|
{
|
|
char User[SHORT_STRING_SIZE];
|
|
char Host[SHORT_STRING_SIZE];
|
|
|
|
if (sockets[sock].f_username == NULL)
|
|
strcpy(User,"unknown");
|
|
else
|
|
strcpy(User,sockets[sock].f_username);
|
|
|
|
if (sockets[sock].f_hostname == NULL)
|
|
strcpy(Host,"unknown");
|
|
else
|
|
strcpy(Host,sockets[sock].f_hostname);
|
|
|
|
close(sockets[sock].descriptor);
|
|
|
|
if (del_socket(&sockets,sock))
|
|
Exit(16);
|
|
|
|
print_msg(PRT_DEBUG_CS,"disconnect from client %s@%s!\n",User,Host);
|
|
print_msg(PRT_DEBUG_CS,"I/O error: %s!\n",strerror(errno));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int eval_message (int sock)
|
|
{
|
|
long int Value;
|
|
int Msg;
|
|
|
|
do
|
|
{
|
|
if ((Value = Read(&(sockets[sock]))) < 0)
|
|
{
|
|
disconnect_client(sock);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Msg = sockets[sock].msg;
|
|
switch(sockets[sock].waitstatus)
|
|
{
|
|
case WF_ACC:
|
|
switch (Msg)
|
|
{
|
|
case MSG_ANNOUNCE:
|
|
new_client(sock);
|
|
break;
|
|
|
|
default:
|
|
/* Meldung: Unbekannter Message-Typ Msg */
|
|
print_msg(PRT_ERR,"Unknown Message %d: %s\n",Msg,sockets[sock].msgbuf.buf);
|
|
disconnect_client(sock);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WF_CLOSE:
|
|
switch (Msg)
|
|
{
|
|
case MSG_CLOSE:
|
|
disconnect_client(sock);
|
|
break;
|
|
|
|
default:
|
|
/* Meldung: Unbekannter Message-Typ Msg */
|
|
print_msg(PRT_ERR,"Unknown Message %d: %s\n",Msg,sockets[sock].msgbuf.buf);
|
|
disconnect_client(sock);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
switch (Msg)
|
|
{
|
|
case MSG_NEW_CALLER:
|
|
Set_Address(sockets[sock].msgbuf.buf);
|
|
break;
|
|
default:
|
|
/* Meldung: Unbekannter Message-Typ Msg */
|
|
print_msg(PRT_ERR,"Unknown Message %d: %s\n",Msg,sockets[sock].msgbuf.buf);
|
|
disconnect_client(sock);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
} while (sockets[sock].status == NEXT_MSG);
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int broadcast_from_server(char* Num, int Flag, int Message, char *String)
|
|
{
|
|
int Cnt;
|
|
|
|
for(Cnt = first_descr; Cnt < socket_size(sockets); Cnt++)
|
|
{
|
|
if (sockets[Cnt].fp == NULL &&
|
|
sockets[Cnt].waitstatus == WF_NOTHING &&
|
|
User_Get_Message(sockets[Cnt].f_username,sockets[Cnt].f_hostname,Num,Flag) == 0)
|
|
{
|
|
sockets[Cnt].msg = Message;
|
|
msgcpy(&(sockets[Cnt]),String,strlen(String)+1);
|
|
|
|
if (Write(&(sockets[Cnt])) < 1)
|
|
disconnect_client(Cnt);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int print_from_server(char *String)
|
|
{
|
|
int RetCode;
|
|
char NewString[LONG_STRING_SIZE];
|
|
time_t t = time(NULL);
|
|
struct tm *tm_time = localtime(&t);
|
|
|
|
|
|
tm_time->tm_isdst = 0;
|
|
|
|
strftime(NewString,LONG_STRING_SIZE,"%b %d %X ",tm_time);
|
|
strcat(NewString,String);
|
|
|
|
if ((RetCode = String_For_Output(NewString)) < 0)
|
|
return RetCode;
|
|
|
|
if ((RetCode = append_Old_Prints(NewString)) < 0)
|
|
return RetCode;
|
|
|
|
return broadcast_from_server(NULL,T_PROTOCOL,MSG_SERVER,NewString);
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int message_from_server(CALL *call, int chan)
|
|
{
|
|
int Cnt;
|
|
int RetCode;
|
|
char *String = Build_Call_Info(call,chan);
|
|
|
|
if ((RetCode = String_For_Output(String)) < 0)
|
|
return RetCode;
|
|
|
|
if ((RetCode = save_messages(String,chan,call->stat)) < 0)
|
|
return RetCode;
|
|
|
|
for(Cnt = first_descr; Cnt < socket_size(sockets); Cnt++)
|
|
{
|
|
if (sockets[Cnt].fp == NULL &&
|
|
sockets[Cnt].waitstatus == WF_NOTHING &&
|
|
User_Get_Message(sockets[Cnt].f_username,sockets[Cnt].f_hostname,call->num[_ME(call)],0) == 0)
|
|
{
|
|
sockets[Cnt].msg = MSG_CALL_INFO;
|
|
msgcpy(&(sockets[Cnt]),String,strlen(String)+1);
|
|
|
|
if (Write(&(sockets[Cnt])) < 1)
|
|
disconnect_client(Cnt);
|
|
else
|
|
if (Write_Caller_Message(Cnt,call) < 0)
|
|
disconnect_client(Cnt);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
char *Build_Call_Info(CALL *call, int chan)
|
|
{
|
|
static char RetCode[LONG_STRING_SIZE];
|
|
|
|
/* Anmerkungen dazu:
|
|
|
|
1. ``connect'' kann auch (time_t)0 sein!
|
|
Dann besteht noch gar keine Verbindung - z.b. weil es gerade
|
|
klingelt, man aber noch nicht abgenommen hat!
|
|
|
|
2. Die ``Dauer'' zu uebertragen halte ich fuer unwichtig - bitte
|
|
korrigiert mich, wenn ich da falsch liege!
|
|
Die Dauer ist doch ``(jetzt) - connect'' ?
|
|
|
|
3. Die Einheiten sind:
|
|
|
|
0 : kostet nix (0130 Gespraech, oder man wird angerufen)
|
|
-1 .. -x : Gebuehrenimpuls
|
|
1 .. x : AOCE (Gebuehreninfo am Ende)
|
|
*/
|
|
|
|
sprintf(RetCode, "%d|%d|%d|%s|%s|%s|%s|%s|%s|%s|%d|%d|%d|%s|%s|%ld|%ld|%g|%g|%s\n",
|
|
chan, /* Kennung: 0 = erste, 1 = zweite laufende Verbindung */
|
|
call->stat, /* Satzart fuer _diese_ Meldung */
|
|
call->dialin, /* 1 = ein Anruf, 0 = man waehlt raus */
|
|
call->num[_ME(call)], /* Eigene MSN */
|
|
call->alias[_ME(call)], /* Alias de eigenen MSN */
|
|
call->num[_OTHER(call)], /* Telefonnummer des Anrufers/Angerufenen (wie von der VSt uebermittelt) */
|
|
call->vorwahl[_OTHER(call)], /* Vorwahl des Anrufers/Angerufenen */
|
|
call->rufnummer[_OTHER(call)], /* Rufnummer des Anrufers/Angerufenen */
|
|
call->alias[_OTHER(call)], /* Alias des Anrufers/Angerufenen */
|
|
call->area[_OTHER(call)], /* Ortsnetz des Anrufers/Angerufenen */
|
|
(int)(call->connect?call->connect:cur_time), /* Beginn (als (time_t) ) */
|
|
(int)(call->connect?cur_time - call->connect:0), /* aktuelle Dauer - in Sekunden seit CONNECT */
|
|
call->aoce, /* Einheiten (negativ: laufende Impulse, positiv: AOCE) */
|
|
double2str(abs(call->aoce) * currency_factor, 6, 2, DEB), /* kostet gerade */
|
|
currency_factor ? currency : "DM", /* Waehrung */
|
|
call->ibytes, /* Frank's ibytes */
|
|
call->obytes, /* Frank's obytes */
|
|
call->ibps, /* Aktueller Durchsatz INPUT: Bytes/Sekunde */
|
|
call->obps, /* Aktueller Durchsatz OUTPUT: Bytes/Sekunde */
|
|
call->msg); /* Status */
|
|
|
|
return RetCode;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int Write_Caller_Message(int sock, CALL *Info)
|
|
{
|
|
char *Address = NULL;
|
|
|
|
if (Info->num[0][0] == '\0')
|
|
return 0;
|
|
|
|
if (User_Get_Message(sockets[sock].f_username,sockets[sock].f_hostname,NULL,T_ADDRESSBOOK) != 0)
|
|
return 0;
|
|
|
|
/* Dirty Hack fuer emulation von neuen Anrufern */
|
|
if (Info->stat == STATE_CONNECT)
|
|
{
|
|
if ((Address = Get_Address(Info->num[0])) == NULL)
|
|
{
|
|
sockets[sock].msg = MSG_WHO_IS;
|
|
msgcpy(&(sockets[sock]),Info->num[0],strlen(Info->num[0])+1);
|
|
|
|
if (Write(&(sockets[sock])) < 1)
|
|
{
|
|
disconnect_client(sock);
|
|
return -1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sockets[sock].msg = MSG_CALLER;
|
|
msgcpy(&(sockets[sock]),Address,strlen(Address)+1);
|
|
|
|
if (Write(&(sockets[sock])) < 1)
|
|
{
|
|
disconnect_client(sock);
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
char *Get_Address(char *Number)
|
|
{
|
|
/* Hier sollte die Adresse zur uebergebenen Telefonummer geliefert werden */
|
|
return NULL;
|
|
return "Burmester:Fred:2::Lohe 4:D:23869:Fischbek:2:04532/123:04532/124:0:0::Elmenhorster Str. 16:D:20000:Hamburg:0:0:1:fred@wo.auch.immer:08.01.68";
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int Set_Address(char *String)
|
|
{
|
|
/* Hier sollte die Adresse zur uebergebenen Telefonummer geliefert werden */
|
|
print_msg(PRT_DEBUG_CS,"New Address*%s*\n",String);
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int save_messages(char *String, int channel, int stat)
|
|
{
|
|
int RetCode;
|
|
|
|
|
|
if (stat == STATE_HANGUP)
|
|
{
|
|
if ((RetCode = del_Cur_Info(channel)) < 0)
|
|
{
|
|
print_msg(PRT_DEBUG_CS,"Invalid Channel No. %d\n",channel);
|
|
}
|
|
|
|
if ((RetCode = append_Old_Info(String)) < 0)
|
|
return RetCode;
|
|
}
|
|
else
|
|
{
|
|
if ((RetCode = add_Cur_Info(channel,String)) < 0)
|
|
return RetCode;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int del_Cur_Info(int channel)
|
|
{
|
|
if (Cur_Info == NULL || Cur_Info[channel] == NULL ||
|
|
channel >= Cur_Info_Size || channel < 0 )
|
|
return -1;
|
|
|
|
free(Cur_Info[channel]);
|
|
Cur_Info[channel] = NULL;
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int append_Old_Prints(char *String)
|
|
{
|
|
int Cnt = 0;
|
|
|
|
if (Old_Prints == NULL)
|
|
if ((Old_Prints = (char**) calloc(xlog,sizeof(char*))) == NULL)
|
|
return NO_MEMORY;
|
|
|
|
|
|
while(Cnt < xlog && Old_Prints[Cnt] != NULL)
|
|
Cnt++;
|
|
|
|
if (Cnt == xlog)
|
|
{
|
|
Cnt = 1;
|
|
|
|
if (Old_Prints[0] != NULL)
|
|
free(Old_Prints[0]);
|
|
|
|
while(Cnt < xlog)
|
|
{
|
|
Old_Prints[Cnt-1] = Old_Prints[Cnt];
|
|
Cnt++;
|
|
}
|
|
|
|
Cnt = xlog - 1;
|
|
}
|
|
|
|
if ((Old_Prints[Cnt] = (char*) calloc(strlen(String)+1,sizeof(char))) == NULL)
|
|
return NO_MEMORY;
|
|
else
|
|
strcpy(Old_Prints[Cnt],String);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int append_Old_Info(char *String)
|
|
{
|
|
int Cnt = 0;
|
|
|
|
|
|
if (Old_Info == NULL)
|
|
if ((Old_Info = (char**) calloc(mcalls,sizeof(char*))) == NULL)
|
|
return NO_MEMORY;
|
|
|
|
|
|
while(Cnt < mcalls && Old_Info[Cnt] != NULL)
|
|
Cnt++;
|
|
|
|
if (Cnt == mcalls)
|
|
{
|
|
Cnt = 1;
|
|
free(Old_Info[0]);
|
|
|
|
while(Cnt < mcalls)
|
|
{
|
|
Old_Info[Cnt-1] = Old_Info[Cnt];
|
|
Cnt++;
|
|
}
|
|
|
|
Cnt = mcalls - 1;
|
|
}
|
|
|
|
if ((Old_Info[Cnt] = (char*) calloc(strlen(String)+1,sizeof(char))) == NULL)
|
|
return NO_MEMORY;
|
|
else
|
|
strcpy(Old_Info[Cnt],String);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int add_Cur_Info(int channel, char *String)
|
|
{
|
|
char **Ptr;
|
|
|
|
|
|
if (channel < 0)
|
|
return 0;
|
|
|
|
if (Cur_Info == NULL)
|
|
if ((Cur_Info = (char**) calloc(channel + 1,sizeof(char*))) == NULL)
|
|
return NO_MEMORY;
|
|
else
|
|
Cur_Info_Size = channel + 1;
|
|
else
|
|
if (channel >= Cur_Info_Size)
|
|
{
|
|
if ((Ptr = (char**) calloc(channel + 1,sizeof(char*))) == NULL)
|
|
return NO_MEMORY;
|
|
|
|
memcpy(Ptr,Cur_Info,Cur_Info_Size*sizeof(char*));
|
|
Cur_Info_Size = channel + 1;
|
|
free(Cur_Info);
|
|
Cur_Info = Ptr;
|
|
}
|
|
|
|
if (Cur_Info[channel] != NULL)
|
|
free(Cur_Info[channel]);
|
|
|
|
if ((Cur_Info[channel] = (char*) calloc(strlen(String)+1,sizeof(char))) == NULL)
|
|
return NO_MEMORY;
|
|
else
|
|
strcpy(Cur_Info[channel],String);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int String_For_Output(char* String)
|
|
{
|
|
char *Ptr;
|
|
char *CurPtr;
|
|
char NewString[LONG_STRING_SIZE];
|
|
|
|
strcpy(NewString,String);
|
|
CurPtr = NewString;
|
|
String[0] = '\0';
|
|
|
|
while ((Ptr = strtok(CurPtr,"\n\r")) != NULL)
|
|
{
|
|
CurPtr = NULL;
|
|
strcat(String,Ptr);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int change_channel(int old_chan, int new_chan)
|
|
{
|
|
int RetCode = 0;
|
|
int Cnt;
|
|
char tmp_string[SHORT_STRING_SIZE];
|
|
char *String = NULL;
|
|
static CALL *Info = NULL;
|
|
|
|
|
|
print_msg(PRT_DEBUG_CS,"Will change channel from %d to %d\n",old_chan,new_chan);
|
|
|
|
if (old_chan < 0 || old_chan >= Cur_Info_Size ||
|
|
new_chan < 0 || Cur_Info[old_chan] == NULL )
|
|
return -1;
|
|
|
|
if (old_chan == new_chan)
|
|
return 0;
|
|
|
|
if ((RetCode = Set_Info_Struct(&Info,Cur_Info[old_chan])) < 0)
|
|
return RetCode;
|
|
|
|
if ((String = Build_Call_Info(Info, new_chan)) == NULL)
|
|
return -1;
|
|
|
|
if ((RetCode = del_Cur_Info(old_chan)) != 0)
|
|
return RetCode;
|
|
|
|
if ((RetCode = add_Cur_Info(new_chan,String)) != 0)
|
|
return RetCode;
|
|
|
|
print_msg(PRT_DEBUG_CS,"Change channel from %d to %d\n",old_chan,new_chan);
|
|
|
|
for(Cnt = first_descr; Cnt < socket_size(sockets); Cnt++)
|
|
{
|
|
if (sockets[Cnt].waitstatus == WF_NOTHING &&
|
|
User_Get_Message(sockets[Cnt].f_username,sockets[Cnt].f_hostname,Info->num[_ME(Info)],0) == 0)
|
|
{
|
|
sockets[Cnt].msg = MSG_CHANGE_CHAN;
|
|
sprintf(tmp_string,"%d%c%d",old_chan,C_DELIMITER,new_chan);
|
|
msgcpy(&(sockets[Cnt]),tmp_string,strlen(tmp_string)+1);
|
|
|
|
if (Write(&(sockets[Cnt])) < 1)
|
|
disconnect_client(Cnt);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|