src/bnetd/handle_telnet.c

/*
 * Copyright (C) 2001  Ross Combs (rocombs@cs.nmsu.edu)
 *
 * 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
 * of the License, 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#include "common/setup_before.h"
#ifdef HAVE_STDDEF_H
# include <stddef.h>
#else
# ifndef NULL
#  define NULL ((void *)0)
# endif
#endif
#ifdef STDC_HEADERS
# include <stdlib.h>
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#else
# ifdef HAVE_STRINGS_H
#  include <strings.h>
# endif
# ifdef HAVE_MEMORY_H
#  include <memory.h>
# endif
#endif
#include "compat/strdup.h"
#include <ctype.h>
#include "common/packet.h"
#include "common/tag.h"
#include "message.h"
#include "common/eventlog.h"
#include "command.h"
#include "account.h"
#include "account_wrap.h"
#include "connection.h"
#include "channel.h"
#include "common/queue.h"
#include "common/bnethash.h"
#include "common/bnethashconv.h"
#include "common/bn_type.h"
#include "common/field_sizes.h"
#include "common/list.h"
#include "common/xalloc.h"
#include "handle_telnet.h"
#include "common/setup_after.h"


extern int handle_telnet_packet(t_connection * c, t_packet const * const packet)
{
    t_packet * rpacket;
    
    if (!c)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"[%d] got NULL connection",conn_get_socket(c));
        return -1;
    }
    if (!packet)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"[%d] got NULL packet",conn_get_socket(c));
        return -1;
    }
    if (packet_get_class(packet)!=packet_class_raw)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"[%d] got bad packet (class %d)",conn_get_socket(c),(int)packet_get_class(packet));
        return -1;
    }
    
    {
        char const * const linestr=packet_get_str_const(packet,0,MAX_MESSAGE_LEN);
        
        if (packet_get_size(packet)<2) /* empty line */
            return 0;
        if (!linestr)
        {
            eventlog(eventlog_level_warn,__FUNCTION__,"[%d] line too long",conn_get_socket(c));
            return 0;
        }
        
        switch (conn_get_state(c))
        {
        case conn_state_connected:
            conn_add_flags(c,MF_PLUG);
            conn_set_clienttag(c,CLIENTTAG_BNCHATBOT_UINT);
            
            {
                char const * temp=linestr;
                
                if (temp[0]=='\004') /* FIXME: no echo, ignore for now (we always do no echo) */
                    temp = &temp[1];
                
                if (temp[0]=='\0') /* empty line */
                {
                    conn_set_state(c,conn_state_bot_username); /* don't look for ^D or reset tag and flags */
                    break;
                }
                
                conn_set_state(c,conn_state_bot_password);
                
                if (conn_set_loggeduser(c,temp)<0)
                    eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not set username to \"%s\"",conn_get_socket(c),temp);
                
                {
                    char const * const msg="\r\nPassword: ";
                    
                    if (!(rpacket = packet_create(packet_class_raw)))
                    {
                        eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
                        break;
                    }
#if 0 /* don't echo */
                    packet_append_ntstring(rpacket,conn_get_loggeduser(c));
#endif
                    packet_append_ntstring(rpacket,msg);
                    conn_push_outqueue(c,rpacket);
                    packet_del_ref(rpacket);
                }
            }
            break;
            
        case conn_state_bot_username:
            conn_set_state(c,conn_state_bot_password);
            
            if (conn_set_loggeduser(c,linestr)<0)
                eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not set username to \"%s\"",conn_get_socket(c),linestr);
            
            {
                char const * const temp="\r\nPassword: ";
                
                if (!(rpacket = packet_create(packet_class_raw)))
                {
                    eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
                    break;
                }
#if 0 /* don't echo */
                packet_append_ntstring(rpacket,linestr);
#endif
                packet_append_ntstring(rpacket,temp);
                conn_push_outqueue(c,rpacket);
                packet_del_ref(rpacket);
            }
            break;
            
        case conn_state_bot_password:
            {
                char const * const tempa="\r\nLogin failed.\r\n\r\nUsername: ";
                char const * const tempb="\r\nAccount has no bot access.\r\n\r\nUsername: ";
                char const * const loggeduser=conn_get_loggeduser(c);
                t_account *        account;
                char const *       oldstrhash1;
                t_hash             trypasshash1;
                t_hash             oldpasshash1;
                char *             testpass;

                if (!loggeduser) /* error earlier in login */
                {
                    /* no log message... */
                    conn_set_state(c,conn_state_bot_username);
                    
                    if (!(rpacket = packet_create(packet_class_raw)))
                    {
                        eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
                        break;
                    }
                    
                    packet_append_ntstring(rpacket,tempa);
                    conn_push_outqueue(c,rpacket);
                    packet_del_ref(rpacket);
                    break;
                }
                if (connlist_find_connection_by_accountname(loggeduser))
                {
                    eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (already logged in)",conn_get_socket(c),loggeduser);
                    conn_set_state(c,conn_state_bot_username);
                    
                    if (!(rpacket = packet_create(packet_class_raw)))
                    {
                        eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
                        break;
                    }
                    
                    packet_append_ntstring(rpacket,tempa);
                    conn_push_outqueue(c,rpacket);
                    packet_del_ref(rpacket);
                    break;
                }
                if (!(account = accountlist_find_account(loggeduser)))
                {
                        eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (bad account)",conn_get_socket(c),loggeduser);
                        conn_set_state(c,conn_state_bot_username);
                        
                        if (!(rpacket = packet_create(packet_class_raw)))
                        {
                            eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
                            break;
                        }
                        
                        packet_append_ntstring(rpacket,tempa);
                        conn_push_outqueue(c,rpacket);
                        packet_del_ref(rpacket);
                    break;
                }
                if ((oldstrhash1 = account_get_pass(account)))
                {
                    if (hash_set_str(&oldpasshash1,oldstrhash1)<0)
                    {
                        eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (corrupted passhash1?)",conn_get_socket(c),account_get_name(account));
                        conn_set_state(c,conn_state_bot_username);

                        if (!(rpacket = packet_create(packet_class_raw)))
                        {
                            eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
                            break;
                        }
                        
                        packet_append_ntstring(rpacket,tempa);
                        conn_push_outqueue(c,rpacket);
                        packet_del_ref(rpacket);
                        break;
                    }

                    testpass = xstrdup(linestr);
                    {
                        unsigned int i;
                        
                        for (i=0; i<strlen(testpass); i++)
                            if (isupper((int)testpass[i]))
                                testpass[i] = tolower((int)testpass[i]);
                    }
                    if (bnet_hash(&trypasshash1,strlen(testpass),testpass)<0) /* FIXME: force to lowercase */
                    {
                        eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (unable to hash password)",conn_get_socket(c),account_get_name(account));
                        xfree(testpass);

                        conn_set_state(c,conn_state_bot_username);

                        if (!(rpacket = packet_create(packet_class_raw)))
                        {
                            eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
                            break;
                        }
                        
                        packet_append_ntstring(rpacket,tempa);
                        conn_push_outqueue(c,rpacket);
                        packet_del_ref(rpacket);
                        break;
                    }
                    xfree(testpass);
                    if (hash_eq(trypasshash1,oldpasshash1)!=1)
                    {
                        eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (wrong password)",conn_get_socket(c),account_get_name(account));
                        conn_set_state(c,conn_state_bot_username);

                        if (!(rpacket = packet_create(packet_class_raw)))
                        {
                            eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
                            break;
                        }
                        
                        packet_append_ntstring(rpacket,tempa);
                        conn_push_outqueue(c,rpacket);
                        packet_del_ref(rpacket);
                        break;
                    }
                    
                    
                    if (account_get_auth_botlogin(account)!=1) /* default to false */
                    {
                        eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (no bot access)",conn_get_socket(c),account_get_name(account));
                        conn_set_state(c,conn_state_bot_username);

                        if (!(rpacket = packet_create(packet_class_raw)))
                        {
                            eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
                            break;
                        }
                        
                        packet_append_ntstring(rpacket,tempb);
                        conn_push_outqueue(c,rpacket);
                        packet_del_ref(rpacket);
                        break;
                    }
                    else if (account_get_auth_lock(account)==1) /* default to false */
                    {
                        eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (this account is locked)",conn_get_socket(c),account_get_name(account));
                        conn_set_state(c,conn_state_bot_username);

                        if (!(rpacket = packet_create(packet_class_raw)))
                        {
                            eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
                            break;
                        }
                        
                        packet_append_ntstring(rpacket,tempb);
                        conn_push_outqueue(c,rpacket);
                        packet_del_ref(rpacket);
                        break;
                    }
                    
                    eventlog(eventlog_level_info,__FUNCTION__,"[%d] \"%s\" bot logged in (correct password)",conn_get_socket(c),account_get_name(account));
                }
                else
                    eventlog(eventlog_level_info,__FUNCTION__,"[%d] \"%s\" bot logged in (no password)",conn_get_socket(c),account_get_name(account));

                    if (!(rpacket = packet_create(packet_class_raw))) /* if we got this far, let them log in even if this fails */
                        eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
                    else
                    {
                        packet_append_ntstring(rpacket,"\r\n");
                        conn_push_outqueue(c,rpacket);
                        packet_del_ref(rpacket);
                    }
                    message_send_text(c,message_type_uniqueid,c,account_get_name(account));

                    conn_login(c,account,loggeduser);

                    if (conn_set_channel(c,CHANNEL_NAME_CHAT)<0)
                        conn_set_channel(c,CHANNEL_NAME_BANNED); /* should not fail */
            }
            break;
            
        case conn_state_loggedin:
            {
                t_channel const * channel;
                
                conn_set_idletime(c);
                
                if ((channel = conn_get_channel(c)))
                    channel_message_log(channel,c,1,linestr);
                /* we don't log game commands currently */
                
                if (linestr[0]=='/')
                    handle_command(c,linestr);
                else
                    if (channel && !conn_quota_exceeded(c,linestr))
                        channel_message_send(channel,message_type_talk,c,linestr);
                    /* else discard */
            }
            break;
            
        default:
            eventlog(eventlog_level_error,__FUNCTION__,"[%d] unknown telnet connection state %d",conn_get_socket(c),(int)conn_get_state(c));
        }
    }
    
    return 0;
}
1	sysadm	1.1	/*
2			* Copyright (C) 2001 Ross Combs (rocombs@cs.nmsu.edu)
3			*
4			* This program is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU General Public License
6			* as published by the Free Software Foundation; either version 2
7			* of the License, or (at your option) any later version.
8			*
9			* This program is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12			* GNU General Public License for more details.
13			*
14			* You should have received a copy of the GNU General Public License
15			* along with this program; if not, write to the Free Software
16			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17			*/
18			#include "common/setup_before.h"
19			#ifdef HAVE_STDDEF_H
20			# include <stddef.h>
21			#else
22			# ifndef NULL
23			# define NULL ((void *)0)
24			# endif
25			#endif
26			#ifdef STDC_HEADERS
27			# include <stdlib.h>
28			#endif
29			#ifdef HAVE_STRING_H
30			# include <string.h>
31			#else
32			# ifdef HAVE_STRINGS_H
33			# include <strings.h>
34			# endif
35			# ifdef HAVE_MEMORY_H
36			# include <memory.h>
37			# endif
38			#endif
39			#include "compat/strdup.h"
40			#include <ctype.h>
41			#include "common/packet.h"
42			#include "common/tag.h"
43			#include "message.h"
44			#include "common/eventlog.h"
45			#include "command.h"
46			#include "account.h"
47			#include "account_wrap.h"
48			#include "connection.h"
49			#include "channel.h"
50			#include "common/queue.h"
51			#include "common/bnethash.h"
52			#include "common/bnethashconv.h"
53			#include "common/bn_type.h"
54			#include "common/field_sizes.h"
55			#include "common/list.h"
56			#include "common/xalloc.h"
57			#include "handle_telnet.h"
58			#include "common/setup_after.h"
59
60
61			extern int handle_telnet_packet(t_connection * c, t_packet const * const packet)
62			{
63			t_packet * rpacket;
64
65			if (!c)
66			{
67			eventlog(eventlog_level_error,__FUNCTION__,"[%d] got NULL connection",conn_get_socket(c));
68			return -1;
69			}
70			if (!packet)
71			{
72			eventlog(eventlog_level_error,__FUNCTION__,"[%d] got NULL packet",conn_get_socket(c));
73			return -1;
74			}
75			if (packet_get_class(packet)!=packet_class_raw)
76			{
77			eventlog(eventlog_level_error,__FUNCTION__,"[%d] got bad packet (class %d)",conn_get_socket(c),(int)packet_get_class(packet));
78			return -1;
79			}
80
81			{
82			char const * const linestr=packet_get_str_const(packet,0,MAX_MESSAGE_LEN);
83
84			if (packet_get_size(packet)<2) /* empty line */
85			return 0;
86			if (!linestr)
87			{
88			eventlog(eventlog_level_warn,__FUNCTION__,"[%d] line too long",conn_get_socket(c));
89			return 0;
90			}
91
92			switch (conn_get_state(c))
93			{
94			case conn_state_connected:
95			conn_add_flags(c,MF_PLUG);
96			conn_set_clienttag(c,CLIENTTAG_BNCHATBOT_UINT);
97
98			{
99			char const * temp=linestr;
100
101			if (temp[0]=='\004') /* FIXME: no echo, ignore for now (we always do no echo) */
102			temp = &temp[1];
103
104			if (temp[0]=='\0') /* empty line */
105			{
106			conn_set_state(c,conn_state_bot_username); /* don't look for ^D or reset tag and flags */
107			break;
108			}
109
110			conn_set_state(c,conn_state_bot_password);
111
112			if (conn_set_loggeduser(c,temp)<0)
113			eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not set username to \"%s\"",conn_get_socket(c),temp);
114
115			{
116			char const * const msg="\r\nPassword: ";
117
118			if (!(rpacket = packet_create(packet_class_raw)))
119			{
120			eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
121			break;
122			}
123			#if 0 /* don't echo */
124			packet_append_ntstring(rpacket,conn_get_loggeduser(c));
125			#endif
126			packet_append_ntstring(rpacket,msg);
127			conn_push_outqueue(c,rpacket);
128			packet_del_ref(rpacket);
129			}
130			}
131			break;
132
133			case conn_state_bot_username:
134			conn_set_state(c,conn_state_bot_password);
135
136			if (conn_set_loggeduser(c,linestr)<0)
137			eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not set username to \"%s\"",conn_get_socket(c),linestr);
138
139			{
140			char const * const temp="\r\nPassword: ";
141
142			if (!(rpacket = packet_create(packet_class_raw)))
143			{
144			eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
145			break;
146			}
147			#if 0 /* don't echo */
148			packet_append_ntstring(rpacket,linestr);
149			#endif
150			packet_append_ntstring(rpacket,temp);
151			conn_push_outqueue(c,rpacket);
152			packet_del_ref(rpacket);
153			}
154			break;
155
156			case conn_state_bot_password:
157			{
158			char const * const tempa="\r\nLogin failed.\r\n\r\nUsername: ";
159			char const * const tempb="\r\nAccount has no bot access.\r\n\r\nUsername: ";
160			char const * const loggeduser=conn_get_loggeduser(c);
161			t_account * account;
162			char const * oldstrhash1;
163			t_hash trypasshash1;
164			t_hash oldpasshash1;
165			char * testpass;
166
167			if (!loggeduser) /* error earlier in login */
168			{
169			/* no log message... */
170			conn_set_state(c,conn_state_bot_username);
171
172			if (!(rpacket = packet_create(packet_class_raw)))
173			{
174			eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
175			break;
176			}
177
178			packet_append_ntstring(rpacket,tempa);
179			conn_push_outqueue(c,rpacket);
180			packet_del_ref(rpacket);
181			break;
182			}
183			if (connlist_find_connection_by_accountname(loggeduser))
184			{
185			eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (already logged in)",conn_get_socket(c),loggeduser);
186			conn_set_state(c,conn_state_bot_username);
187
188			if (!(rpacket = packet_create(packet_class_raw)))
189			{
190			eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
191			break;
192			}
193
194			packet_append_ntstring(rpacket,tempa);
195			conn_push_outqueue(c,rpacket);
196			packet_del_ref(rpacket);
197			break;
198			}
199			if (!(account = accountlist_find_account(loggeduser)))
200			{
201			eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (bad account)",conn_get_socket(c),loggeduser);
202			conn_set_state(c,conn_state_bot_username);
203
204			if (!(rpacket = packet_create(packet_class_raw)))
205			{
206			eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
207			break;
208			}
209
210			packet_append_ntstring(rpacket,tempa);
211			conn_push_outqueue(c,rpacket);
212			packet_del_ref(rpacket);
213			break;
214			}
215			if ((oldstrhash1 = account_get_pass(account)))
216			{
217			if (hash_set_str(&oldpasshash1,oldstrhash1)<0)
218			{
219			eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (corrupted passhash1?)",conn_get_socket(c),account_get_name(account));
220			conn_set_state(c,conn_state_bot_username);
221
222			if (!(rpacket = packet_create(packet_class_raw)))
223			{
224			eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
225			break;
226			}
227
228			packet_append_ntstring(rpacket,tempa);
229			conn_push_outqueue(c,rpacket);
230			packet_del_ref(rpacket);
231			break;
232			}
233
234			testpass = xstrdup(linestr);
235			{
236			unsigned int i;
237
238			for (i=0; i<strlen(testpass); i++)
239			if (isupper((int)testpass[i]))
240			testpass[i] = tolower((int)testpass[i]);
241			}
242			if (bnet_hash(&trypasshash1,strlen(testpass),testpass)<0) /* FIXME: force to lowercase */
243			{
244			eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (unable to hash password)",conn_get_socket(c),account_get_name(account));
245			xfree(testpass);
246
247			conn_set_state(c,conn_state_bot_username);
248
249			if (!(rpacket = packet_create(packet_class_raw)))
250			{
251			eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
252			break;
253			}
254
255			packet_append_ntstring(rpacket,tempa);
256			conn_push_outqueue(c,rpacket);
257			packet_del_ref(rpacket);
258			break;
259			}
260			xfree(testpass);
261			if (hash_eq(trypasshash1,oldpasshash1)!=1)
262			{
263			eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (wrong password)",conn_get_socket(c),account_get_name(account));
264			conn_set_state(c,conn_state_bot_username);
265
266			if (!(rpacket = packet_create(packet_class_raw)))
267			{
268			eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
269			break;
270			}
271
272			packet_append_ntstring(rpacket,tempa);
273			conn_push_outqueue(c,rpacket);
274			packet_del_ref(rpacket);
275			break;
276			}
277
278
279			if (account_get_auth_botlogin(account)!=1) /* default to false */
280			{
281			eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (no bot access)",conn_get_socket(c),account_get_name(account));
282			conn_set_state(c,conn_state_bot_username);
283
284			if (!(rpacket = packet_create(packet_class_raw)))
285			{
286			eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
287			break;
288			}
289
290			packet_append_ntstring(rpacket,tempb);
291			conn_push_outqueue(c,rpacket);
292			packet_del_ref(rpacket);
293			break;
294			}
295			else if (account_get_auth_lock(account)==1) /* default to false */
296			{
297			eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (this account is locked)",conn_get_socket(c),account_get_name(account));
298			conn_set_state(c,conn_state_bot_username);
299
300			if (!(rpacket = packet_create(packet_class_raw)))
301			{
302			eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
303			break;
304			}
305
306			packet_append_ntstring(rpacket,tempb);
307			conn_push_outqueue(c,rpacket);
308			packet_del_ref(rpacket);
309			break;
310			}
311
312			eventlog(eventlog_level_info,__FUNCTION__,"[%d] \"%s\" bot logged in (correct password)",conn_get_socket(c),account_get_name(account));
313			}
314			else
315			eventlog(eventlog_level_info,__FUNCTION__,"[%d] \"%s\" bot logged in (no password)",conn_get_socket(c),account_get_name(account));
316
317			if (!(rpacket = packet_create(packet_class_raw))) /* if we got this far, let them log in even if this fails */
318			eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
319			else
320			{
321			packet_append_ntstring(rpacket,"\r\n");
322			conn_push_outqueue(c,rpacket);
323			packet_del_ref(rpacket);
324			}
325			message_send_text(c,message_type_uniqueid,c,account_get_name(account));
326
327			conn_login(c,account,loggeduser);
328
329			if (conn_set_channel(c,CHANNEL_NAME_CHAT)<0)
330			conn_set_channel(c,CHANNEL_NAME_BANNED); /* should not fail */
331			}
332			break;
333
334			case conn_state_loggedin:
335			{
336			t_channel const * channel;
337
338			conn_set_idletime(c);
339
340			if ((channel = conn_get_channel(c)))
341			channel_message_log(channel,c,1,linestr);
342			/* we don't log game commands currently */
343
344			if (linestr[0]=='/')
345			handle_command(c,linestr);
346			else
347			if (channel && !conn_quota_exceeded(c,linestr))
348			channel_message_send(channel,message_type_talk,c,linestr);
349			/* else discard */
350			}
351			break;
352
353			default:
354			eventlog(eventlog_level_error,__FUNCTION__,"[%d] unknown telnet connection state %d",conn_get_socket(c),(int)conn_get_state(c));
355			}
356			}
357
358			return 0;
359			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1