Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/teraterm/telnet.c

Annotation of /trunk/teraterm/teraterm/telnet.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 6962 - (hide annotations) (download) (as text)
Fri Oct 27 09:40:50 2017 UTC (6 years, 5 months ago) by doda
File MIME type: text/x-csrc
File size: 17039 byte(s) 
対応するサブオプションの数が増えてきたので、switch を使うようにした。
1 doda 6806 /*
2     * Copyright (C) 1994-1998 T. Teranishi
3     * (C) 2007-2017 TeraTerm Project
4     * All rights reserved.
5     *
6 doda 6841 * Redistribution and use in source and binary forms, with or without
7     * modification, are permitted provided that the following conditions
8     * are met:
9 doda 6806 *
10 doda 6841 * 1. Redistributions of source code must retain the above copyright
11     * notice, this list of conditions and the following disclaimer.
12     * 2. Redistributions in binary form must reproduce the above copyright
13     * notice, this list of conditions and the following disclaimer in the
14     * documentation and/or other materials provided with the distribution.
15     * 3. The name of the author may not be used to endorse or promote products
16     * derived from this software without specific prior written permission.
17 doda 6806 *
18 doda 6841 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
19     * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20     * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21     * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22     * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23     * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24     * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25     * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26     * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27     * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 doda 6806 */
29 maya 3227
30     /* TERATERM.EXE, TELNET routines */
31    
32     #include "teraterm.h"
33     #include "tttypes.h"
34     #include <stdio.h>
35     #include <string.h>
36     #include "ttcommon.h"
37     #include "ttwinman.h"
38     #include "commlib.h"
39     #include <time.h>
40     #include <process.h>
41    
42     #include "telnet.h"
43     #include "tt_res.h"
44    
45     int TelStatus;
46    
47     enum OptStatus {No, Yes, WantNo, WantYes};
48     enum OptQue {Empty, Opposite};
49    
50     typedef struct {
51 doda 6961 BOOL Accept;
52     enum OptStatus Status;
53     enum OptQue Que;
54 maya 3227 } TelOpt;
55     typedef TelOpt *PTelOpt;
56    
57     typedef struct {
58 doda 6961 TelOpt MyOpt[MaxTelOpt+1];
59     TelOpt HisOpt[MaxTelOpt+1];
60     BYTE SubOptBuff[51];
61     int SubOptCount;
62     BOOL SubOptIAC;
63     BOOL ChangeWinSize;
64     POINT WinSize;
65     int LogFile;
66 maya 3227 } TelRec;
67     typedef TelRec *PTelRec;
68    
69     static TelRec tr;
70    
71     static HANDLE keepalive_thread = (HANDLE)-1L;
72 doda 6435 static HWND keepalive_dialog = NULL;
73 maya 3227 int nop_interval = 0;
74    
75     void DefaultTelRec()
76     {
77 doda 6961 int i;
78 maya 3227
79 doda 6961 for (i=0 ; i <= MaxTelOpt ; i++) {
80     tr.MyOpt[i].Accept = FALSE;
81     tr.MyOpt[i].Status = No;
82     tr.MyOpt[i].Que = Empty;
83     tr.HisOpt[i].Accept = FALSE;
84     tr.HisOpt[i].Status = No;
85     tr.HisOpt[i].Que = Empty;
86     }
87 maya 3227
88 doda 6961 tr.SubOptCount = 0;
89     tr.SubOptIAC = FALSE;
90     tr.ChangeWinSize = FALSE;
91 maya 3227 }
92    
93     void InitTelnet()
94     {
95 doda 6961 TelStatus = TelIdle;
96 maya 3227
97 doda 6961 DefaultTelRec();
98     tr.MyOpt[BINARY].Accept = TRUE;
99     tr.HisOpt[BINARY].Accept = TRUE;
100     tr.MyOpt[SGA].Accept = TRUE;
101     tr.HisOpt[SGA].Accept = TRUE;
102     tr.HisOpt[ECHO].Accept = TRUE;
103     tr.MyOpt[TERMTYPE].Accept = TRUE;
104     tr.MyOpt[TERMSPEED].Accept = TRUE;
105     tr.MyOpt[NAWS].Accept = TRUE;
106     tr.HisOpt[NAWS].Accept = TRUE;
107     tr.WinSize.x = ts.TerminalWidth;
108     tr.WinSize.y = ts.TerminalHeight;
109 maya 3227
110 doda 6961 if ((ts.LogFlag & LOG_TEL) != 0)
111     tr.LogFile = _lcreat("TELNET.LOG", 0);
112     else
113     tr.LogFile = 0;
114 maya 3227 }
115    
116     void EndTelnet()
117     {
118 doda 6961 if (tr.LogFile) {
119     tr.LogFile = 0;
120     _lclose(tr.LogFile);
121     }
122 maya 3227
123 doda 6961 TelStopKeepAliveThread();
124 maya 3227 }
125    
126     void TelWriteLog1(BYTE b)
127     {
128 doda 6961 BYTE Temp[3];
129     BYTE Ch;
130 maya 3227
131 doda 6961 Temp[0] = 0x20;
132     Ch = b / 16;
133     if (Ch <= 9)
134     Ch = Ch + 0x30;
135     else
136     Ch = Ch + 0x37;
137     Temp[1] = Ch;
138 maya 3227
139 doda 6961 Ch = b & 15;
140     if (Ch <= 9)
141     Ch = Ch + 0x30;
142     else
143     Ch = Ch + 0x37;
144     Temp[2] = Ch;
145     _lwrite(tr.LogFile, Temp, 3);
146 maya 3227 }
147    
148     void TelWriteLog(PCHAR Buf, int C)
149     {
150 doda 6961 int i;
151 maya 3227
152 doda 6961 _lwrite(tr.LogFile, "\015\012>", 3);
153     for (i = 0 ; i<= C-1 ; i++)
154     TelWriteLog1(Buf[i]);
155 maya 3227 }
156    
157     void SendBack(BYTE a, BYTE b)
158     {
159 doda 6961 BYTE Str3[3];
160 maya 3227
161 doda 6961 Str3[0] = IAC;
162     Str3[1] = a;
163     Str3[2] = b;
164     CommRawOut(&cv, Str3, 3);
165     if (tr.LogFile)
166     TelWriteLog(Str3, 3);
167 maya 3227 }
168    
169     void SendWinSize()
170     {
171 doda 6961 int i;
172     BYTE TmpBuff[21];
173 maya 3227
174 doda 6961 i = 0;
175 maya 3227
176 doda 6961 TmpBuff[i++] = IAC;
177     TmpBuff[i++] = SB;
178     TmpBuff[i++] = NAWS;
179     TmpBuff[i++] = HIBYTE(tr.WinSize.x);
180     // if (LOBYTE(tr.WinSize.x) == IAC) {
181     // tr.SendBackBuff[i++] = IAC;
182     // }
183     TmpBuff[i++] = LOBYTE(tr.WinSize.x);
184     TmpBuff[i++] = HIBYTE(tr.WinSize.y);
185     // if (LOBYTE(tr.WinSize.y) == IAC) {
186     // tr.SendBackBuff[i++] = IAC;
187     // }
188     TmpBuff[i++] = LOBYTE(tr.WinSize.y);
189     TmpBuff[i++] = IAC;
190     TmpBuff[i++] = SE;
191 maya 3227
192 doda 6961 CommRawOut(&cv, TmpBuff, i);
193     if (tr.LogFile)
194     TelWriteLog(TmpBuff, i);
195 maya 3227 }
196    
197     void ParseTelIAC(BYTE b)
198     {
199 doda 6961 switch (b) {
200     case SE: break;
201     case NOP:
202     case DM:
203     case BREAK:
204     case IP:
205     case AO:
206     case AYT:
207     case EC:
208     case EL:
209     case GOAHEAD:
210     TelStatus = TelIdle;
211     break;
212     case SB:
213     TelStatus = TelSB;
214     tr.SubOptCount = 0;
215     break;
216     case WILLTEL:
217     TelStatus = TelWill;
218     break;
219     case WONTTEL:
220     TelStatus = TelWont;
221     break;
222     case DOTEL:
223     TelStatus = TelDo;
224     break;
225     case DONTTEL:
226     TelStatus = TelDont;
227     break;
228     case IAC:
229     TelStatus = TelIdle;
230     break;
231     default:
232     TelStatus = TelIdle;
233     }
234 maya 3227 }
235    
236     void ParseTelSB(BYTE b)
237     {
238 doda 6959 BYTE TmpStr[51];
239     int i;
240 maya 3227
241 doda 6959 if (tr.SubOptIAC) {
242     tr.SubOptIAC = FALSE;
243     switch (b) {
244     case SE:
245 doda 6962 if (tr.SubOptCount <= 1) {
246     // �p�����[�^������ Sub Option ���������v����������������������
247     tr.SubOptCount = 0;
248     TelStatus = TelIdle;
249     return ;
250     }
251 maya 3227
252 doda 6962 switch (tr.SubOptBuff[0]) {
253     case TERMTYPE:
254     if ((tr.MyOpt[TERMTYPE].Status == Yes) && (tr.SubOptBuff[1] == 1)) {
255     _snprintf_s(TmpStr, sizeof(TmpStr), _TRUNCATE, "%c%c%c%c%s%c%c",
256     IAC, SB, TERMTYPE, 0, ts.TermType, IAC, SE);
257     // 4 �o�C�g���� 0 �����������A������������������
258     i = strlen(TmpStr + 4) + 4;
259     CommRawOut(&cv, TmpStr, i);
260    
261     if (tr.LogFile)
262     TelWriteLog(TmpStr, i);
263     }
264     break;
265    
266     case NAWS:
267     if ( /* (tr.HisOpt[NAWS].Status == Yes) && */ (tr.SubOptCount >= 5)) {
268     tr.WinSize.x = tr.SubOptBuff[1]*256 + tr.SubOptBuff[2];
269     tr.WinSize.y = tr.SubOptBuff[3]*256 + tr.SubOptBuff[4];
270     tr.ChangeWinSize = TRUE;
271     }
272     break;
273    
274     case TERMSPEED:
275     if ((tr.MyOpt[TERMSPEED].Status == Yes) && (tr.SubOptBuff[1] == 1)) {
276     _snprintf_s(TmpStr, sizeof(TmpStr), _TRUNCATE,
277     "%c%c%c%c%d,%d%c%c", IAC, SB, TERMSPEED, 0,
278     ts.TerminalInputSpeed, ts.TerminalOutputSpeed, IAC, SE);
279     // 4 �o�C�g���� 0 �����������A������������������
280     i = strlen(TmpStr + 4) + 4;
281     CommRawOut(&cv, TmpStr, i);
282    
283     if (tr.LogFile)
284     TelWriteLog(TmpStr, i);
285     }
286     break;
287 doda 6959 }
288 doda 6960
289 doda 6959 tr.SubOptCount = 0;
290     TelStatus = TelIdle;
291     return ;
292 doda 6962
293 doda 6959 /* case IAC: braek; */
294     default:
295     if (tr.SubOptCount >= sizeof(tr.SubOptBuff)-1) {
296     tr.SubOptCount = 0;
297     TelStatus = TelIdle;
298     return;
299     }
300     else {
301     tr.SubOptBuff[tr.SubOptCount] = IAC;
302     tr.SubOptCount++;
303     if (b==IAC) {
304     tr.SubOptIAC = TRUE;
305     return;
306     }
307     }
308     }
309 maya 3227 }
310 doda 6959 else if (b==IAC) {
311     tr.SubOptIAC = TRUE;
312     return;
313 maya 3227 }
314 doda 6959
315     if (tr.SubOptCount >= sizeof(tr.SubOptBuff)-1) {
316     tr.SubOptCount = 0;
317     tr.SubOptIAC = FALSE;
318     TelStatus = TelIdle;
319 maya 3227 }
320     else {
321 doda 6959 tr.SubOptBuff[tr.SubOptCount] = b;
322     tr.SubOptCount++;
323 maya 3227 }
324     }
325    
326     void ParseTelWill(BYTE b)
327     {
328 doda 6961 if (b <= MaxTelOpt) {
329     switch (tr.HisOpt[b].Status) {
330     case No:
331     if (tr.HisOpt[b].Accept) {
332     SendBack(DOTEL, b);
333     tr.HisOpt[b].Status = Yes;
334     }
335     else {
336     SendBack(DONTTEL, b);
337     }
338     break;
339 doda 6435
340 doda 6961 case WantNo:
341     switch (tr.HisOpt[b].Que) {
342     case Empty:
343     tr.HisOpt[b].Status = No;
344     break;
345     case Opposite:
346     tr.HisOpt[b].Status = Yes;
347     break;
348     }
349     break;
350 maya 3227
351 doda 6961 case WantYes:
352     switch (tr.HisOpt[b].Que) {
353     case Empty:
354     tr.HisOpt[b].Status = Yes;
355     break;
356     case Opposite:
357     tr.HisOpt[b].Status = WantNo;
358     tr.HisOpt[b].Que = Empty;
359     SendBack(DONTTEL, b);
360     break;
361     }
362     break;
363     }
364 maya 3227 }
365 doda 6961 else {
366     SendBack(DONTTEL, b);
367     }
368 maya 3227
369 doda 6961 switch (b) {
370     case ECHO:
371     if (ts.TelEcho) {
372     switch (tr.HisOpt[ECHO].Status) {
373     case Yes:
374     ts.LocalEcho = 0;
375     break;
376     case No:
377     ts.LocalEcho = 1;
378     break;
379     }
380     }
381     if (tr.HisOpt[ECHO].Status == Yes) {
382     cv.TelLineMode = FALSE;
383     }
384     break;
385    
386     case SGA:
387     if (tr.HisOpt[SGA].Status == Yes) {
388     cv.TelLineMode = FALSE;
389     }
390     break;
391    
392     case BINARY:
393     switch (tr.HisOpt[BINARY].Status) {
394     case Yes:
395     cv.TelBinRecv = TRUE;
396     break;
397     case No:
398     cv.TelBinRecv = FALSE;
399     break;
400     }
401     break;
402 maya 3227 }
403 doda 6961 TelStatus = TelIdle;
404 maya 3227 }
405    
406     void ParseTelWont(BYTE b)
407     {
408 doda 6961 if (b <= MaxTelOpt) {
409     switch (tr.HisOpt[b].Status) {
410     case Yes:
411     tr.HisOpt[b].Status = No;
412     SendBack(DONTTEL, b);
413     break;
414 maya 3227
415 doda 6961 case WantNo:
416     switch (tr.HisOpt[b].Que) {
417     case Empty:
418     tr.HisOpt[b].Status = No;
419     break;
420     case Opposite:
421     tr.HisOpt[b].Status = WantYes;
422     tr.HisOpt[b].Que = Empty;
423     SendBack(DOTEL, b);
424     break;
425     }
426     break;
427 maya 3227
428 doda 6961 case WantYes:
429     switch (tr.HisOpt[b].Que) {
430     case Empty:
431     tr.HisOpt[b].Status = No;
432     break;
433     case Opposite:
434     tr.HisOpt[b].Status = No;
435     tr.HisOpt[b].Que = Empty;
436     break;
437     }
438     break;
439     }
440 maya 3227 }
441 doda 6961 else {
442     SendBack(DONTTEL, b);
443     }
444 maya 3227
445 doda 6961 switch (b) {
446     case ECHO:
447     if (ts.TelEcho) {
448     switch (tr.HisOpt[ECHO].Status) {
449     case Yes:
450     ts.LocalEcho = 0;
451     break;
452     case No:
453     ts.LocalEcho = 1;
454     break;
455     }
456     }
457     if (tr.HisOpt[ECHO].Status == Yes) {
458     cv.TelLineMode = FALSE;
459     }
460     break;
461    
462     case BINARY:
463     switch (tr.HisOpt[BINARY].Status) {
464     case Yes:
465     cv.TelBinRecv = TRUE;
466     break;
467     case No:
468     cv.TelBinRecv = FALSE;
469     break;
470     }
471     break;
472 maya 3227 }
473 doda 6961 TelStatus = TelIdle;
474 maya 3227 }
475    
476     void ParseTelDo(BYTE b)
477     {
478 doda 6961 if (b <= MaxTelOpt) {
479     switch (tr.MyOpt[b].Status) {
480     case No:
481     if (tr.MyOpt[b].Accept) {
482     tr.MyOpt[b].Status = Yes;
483     SendBack(WILLTEL, b);
484     }
485     else {
486     SendBack(WONTTEL, b);
487     }
488     break;
489 maya 3227
490 doda 6961 case WantNo:
491     switch (tr.MyOpt[b].Que) {
492     case Empty:
493     tr.MyOpt[b].Status = No;
494     break;
495     case Opposite:
496     tr.MyOpt[b].Status = Yes;
497     break;
498     }
499     break;
500    
501     case WantYes:
502     switch (tr.MyOpt[b].Que) {
503     case Empty:
504     tr.MyOpt[b].Status = Yes;
505     break;
506     case Opposite:
507     tr.MyOpt[b].Status = WantNo;
508     tr.MyOpt[b].Que = Empty;
509     SendBack(WONTTEL, b);
510     break;
511     }
512     break;
513     }
514 maya 3227 }
515 doda 6961 else {
516     SendBack(WONTTEL, b);
517     }
518 maya 3227
519 doda 6961 switch (b) {
520     case BINARY:
521     switch (tr.MyOpt[BINARY].Status) {
522     case Yes:
523     cv.TelBinSend = TRUE;
524     break;
525     case No:
526     cv.TelBinSend = FALSE;
527     break;
528     }
529     break;
530    
531     case NAWS:
532     if (tr.MyOpt[NAWS].Status==Yes)
533     SendWinSize();
534     break;
535    
536     case SGA:
537     if (tr.MyOpt[SGA].Status==Yes)
538     cv.TelLineMode = FALSE;
539     break;
540 maya 3227 }
541 doda 6961 TelStatus = TelIdle;
542 maya 3227 }
543    
544     void ParseTelDont(BYTE b)
545     {
546 doda 6961 if (b <= MaxTelOpt) {
547     switch (tr.MyOpt[b].Status) {
548     case Yes:
549     tr.MyOpt[b].Status = No;
550     SendBack(WONTTEL, b);
551     break;
552 maya 3227
553 doda 6961 case WantNo:
554     switch (tr.MyOpt[b].Que) {
555     case Empty:
556     tr.MyOpt[b].Status = No;
557     break;
558     case Opposite:
559     tr.MyOpt[b].Status = WantYes;
560     tr.MyOpt[b].Que = Empty;
561     SendBack(WILLTEL, b);
562     break;
563     }
564     break;
565    
566     case WantYes:
567     switch (tr.MyOpt[b].Que) {
568     case Empty:
569     tr.MyOpt[b].Status = No;
570     break;
571     case Opposite:
572     tr.MyOpt[b].Status = No;
573     tr.MyOpt[b].Que = Empty;
574     break;
575     }
576     break;
577     }
578 maya 3227 }
579 doda 6961 else {
580     SendBack(WONTTEL, b);
581     }
582 maya 3227
583 doda 6961 switch (b) {
584     case BINARY:
585     switch (tr.MyOpt[BINARY].Status) {
586     case Yes:
587     cv.TelBinSend = TRUE;
588     break;
589     case No:
590     cv.TelBinSend = FALSE;
591     break;
592     }
593     break;
594 maya 3227 }
595 doda 6961 TelStatus = TelIdle;
596 maya 3227 }
597    
598     void ParseTel(BOOL *Size, int *nx, int *ny)
599     {
600 doda 6961 BYTE b;
601     int c;
602 maya 3227
603 doda 6961 c = CommReadRawByte(&cv, &b);
604 maya 3227
605 doda 6961 while ((c>0) && (cv.TelMode)) {
606     if (tr.LogFile) {
607     if (TelStatus==TelIAC) {
608     _lwrite(tr.LogFile, "\015\012<", 3);
609     TelWriteLog1(0xff);
610     }
611     TelWriteLog1(b);
612     }
613 maya 3227
614 doda 6961 tr.ChangeWinSize = FALSE;
615 maya 3227
616 doda 6961 switch (TelStatus) {
617     case TelIAC: ParseTelIAC(b); break;
618     case TelSB: ParseTelSB(b); break;
619     case TelWill: ParseTelWill(b); break;
620     case TelWont: ParseTelWont(b); break;
621     case TelDo: ParseTelDo(b); break;
622     case TelDont: ParseTelDont(b); break;
623     case TelNop: TelStatus = TelIdle; break;
624     }
625     if (TelStatus == TelIdle) cv.TelMode = FALSE;
626 maya 3227
627 doda 6961 if (cv.TelMode) c = CommReadRawByte(&cv, &b);
628     }
629 maya 3227
630 doda 6961 *Size = tr.ChangeWinSize;
631     *nx = tr.WinSize.x;
632     *ny = tr.WinSize.x;
633 maya 3227 }
634    
635     void TelEnableHisOpt(BYTE b)
636     {
637 doda 6961 if (b <= MaxTelOpt) {
638     switch (tr.HisOpt[b].Status) {
639     case No:
640     tr.HisOpt[b].Status = WantYes;
641     SendBack(DOTEL, b);
642     break;
643 maya 3227
644 doda 6961 case WantNo:
645     if (tr.HisOpt[b].Que==Empty)
646     tr.HisOpt[b].Que = Opposite;
647     break;
648 maya 3227
649 doda 6961 case WantYes:
650     if (tr.HisOpt[b].Que==Opposite)
651     tr.HisOpt[b].Que = Empty;
652     break;
653     }
654     }
655 maya 3227 }
656    
657     void TelDisableHisOpt(BYTE b)
658     {
659 doda 6961 if (b <= MaxTelOpt) {
660     switch (tr.HisOpt[b].Status) {
661     case Yes:
662     tr.HisOpt[b].Status = WantNo;
663     SendBack(DONTTEL, b);
664     break;
665 maya 3227
666 doda 6961 case WantNo:
667     if (tr.HisOpt[b].Que==Opposite)
668     tr.HisOpt[b].Que = Empty;
669     break;
670 maya 3227
671 doda 6961 case WantYes:
672     if (tr.HisOpt[b].Que==Empty)
673     tr.HisOpt[b].Que = Opposite;
674     break;
675     }
676     }
677 maya 3227 }
678    
679     void TelEnableMyOpt(BYTE b)
680     {
681 doda 6961 if (b <= MaxTelOpt) {
682     switch (tr.MyOpt[b].Status) {
683     case No:
684     tr.MyOpt[b].Status = WantYes;
685     SendBack(WILLTEL, b);
686     break;
687 maya 3227
688 doda 6961 case WantNo:
689     if (tr.MyOpt[b].Que==Empty)
690     tr.MyOpt[b].Que = Opposite;
691     break;
692 maya 3227
693 doda 6961 case WantYes:
694     if (tr.MyOpt[b].Que==Opposite)
695     tr.MyOpt[b].Que = Empty;
696     break;
697     }
698     }
699 maya 3227 }
700    
701     void TelDisableMyOpt(BYTE b)
702     {
703 doda 6961 if (b <= MaxTelOpt) {
704     switch (tr.MyOpt[b].Status) {
705     case Yes:
706     tr.MyOpt[b].Status = WantNo;
707     SendBack(WONTTEL, b);
708     break;
709 maya 3227
710 doda 6961 case WantNo:
711     if (tr.MyOpt[b].Que==Opposite)
712     tr.MyOpt[b].Que = Empty;
713     break;
714 maya 3227
715 doda 6961 case WantYes:
716     if (tr.MyOpt[b].Que==Empty)
717     tr.MyOpt[b].Que = Opposite;
718     break;
719     }
720     }
721 maya 3227 }
722    
723     void TelInformWinSize(int nx, int ny)
724     {
725 doda 6961 if ((tr.MyOpt[NAWS].Status==Yes) &&
726     (nx != tr.WinSize.x || ny != tr.WinSize.y))
727     {
728     tr.WinSize.x = nx;
729     tr.WinSize.y = ny;
730     SendWinSize();
731     }
732 maya 3227 }
733    
734     void TelSendAYT()
735     {
736 doda 6961 BYTE Str[2];
737 maya 3227
738 doda 6961 Str[0] = IAC;
739     Str[1] = AYT;
740     CommRawOut(&cv, Str, 2);
741     CommSend(&cv);
742     if (tr.LogFile)
743     TelWriteLog(Str, 2);
744 maya 3227 }
745    
746     void TelSendBreak()
747     {
748 doda 6961 BYTE Str[2];
749 maya 3227
750 doda 6961 Str[0] = IAC;
751     Str[1] = BREAK;
752     CommRawOut(&cv, Str, 2);
753     CommSend(&cv);
754     if (tr.LogFile)
755     TelWriteLog(Str, 2);
756 maya 3227 }
757    
758     void TelChangeEcho()
759     {
760 doda 6961 if (ts.LocalEcho==0)
761     TelEnableHisOpt(ECHO);
762     else
763     TelDisableHisOpt(ECHO);
764 maya 3227 }
765    
766     void TelSendNOP()
767     {
768 doda 6961 BYTE Str[2];
769 maya 3227
770 doda 6961 Str[0] = IAC;
771     Str[1] = NOP;
772     CommRawOut(&cv, Str, 2);
773     CommSend(&cv);
774     if (tr.LogFile)
775     TelWriteLog(Str, 2);
776 maya 3227 }
777    
778     #define WM_SEND_HEARTBEAT (WM_USER + 1)
779    
780     static LRESULT CALLBACK telnet_heartbeat_dlg_proc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
781     {
782     switch (msg) {
783 doda 6961 case WM_INITDIALOG:
784     return FALSE;
785 maya 3227
786 doda 6961 case WM_SEND_HEARTBEAT:
787     TelSendNOP();
788     return TRUE;
789     break;
790 maya 3227
791 doda 6961 case WM_COMMAND:
792     switch (LOWORD(wp)) {
793     case IDOK:
794 maya 3227 return TRUE;
795 doda 6961 case IDCANCEL:
796     EndDialog(hWnd, 0);
797 maya 3227 return TRUE;
798     default:
799     return FALSE;
800 doda 6961 }
801     break;
802    
803     case WM_CLOSE:
804     // close�{�^���������������� window ���������������������B
805     return TRUE;
806    
807     case WM_DESTROY:
808     return TRUE;
809    
810     default:
811     return FALSE;
812 maya 3227 }
813     return TRUE;
814     }
815    
816    
817     static unsigned _stdcall TelKeepAliveThread(void *dummy) {
818 doda 6961 static int instance = 0;
819 maya 3227
820 doda 6961 if (instance > 0)
821     return 0;
822     instance++;
823 maya 3227
824 doda 6961 while (cv.Open && nop_interval > 0) {
825     if (time(NULL) >= cv.LastSendTime + nop_interval) {
826     SendMessage(keepalive_dialog, WM_SEND_HEARTBEAT, 0, 0);
827     }
828 maya 3227
829 doda 6961 Sleep(100);
830     }
831     instance--;
832     return 0;
833 maya 3227 }
834    
835     void TelStartKeepAliveThread() {
836 doda 6961 unsigned tid;
837 maya 3227
838 doda 6961 if (ts.TelKeepAliveInterval > 0) {
839     nop_interval = ts.TelKeepAliveInterval;
840 maya 3227
841     // ���[�h���X�_�C�A���O������ (2007.12.26 yutaka)
842     keepalive_dialog = CreateDialog(hInst, MAKEINTRESOURCE(IDD_BROADCAST_DIALOG),
843 doda 6961 HVTWin, (DLGPROC)telnet_heartbeat_dlg_proc);
844 maya 3227
845 doda 6961 keepalive_thread = (HANDLE)_beginthreadex(NULL, 0, TelKeepAliveThread, NULL, 0, &tid);
846     if (keepalive_thread == (HANDLE)-1) {
847     nop_interval = 0;
848     }
849     }
850 maya 3227 }
851    
852     void TelStopKeepAliveThread() {
853 doda 6961 if (keepalive_thread != (HANDLE)-1L) {
854     nop_interval = 0;
855     WaitForSingleObject(keepalive_thread, INFINITE);
856     CloseHandle(keepalive_thread);
857     keepalive_thread = (HANDLE)-1L;
858 maya 3227
859 doda 6961 DestroyWindow(keepalive_dialog);
860     }
861 maya 3227 }
862    
863     void TelUpdateKeepAliveInterval() {
864 doda 6961 if (cv.Open && cv.TelFlag && ts.TCPPort==ts.TelPort) {
865     if (ts.TelKeepAliveInterval > 0 && keepalive_thread == (HANDLE)-1)
866     TelStartKeepAliveThread();
867     else if (ts.TelKeepAliveInterval == 0 && keepalive_thread != (HANDLE)-1)
868     TelStopKeepAliveThread();
869     else
870     nop_interval = ts.TelKeepAliveInterval;
871     }
872 maya 3227 }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help