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 6961 - (hide annotations) (download) (as text)
Fri Oct 27 09:40:46 2017 UTC (6 years, 5 months ago) by doda
File MIME type: text/x-csrc
File size: 16991 byte(s) 
インデント変更
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     if ((tr.MyOpt[TERMTYPE].Status == Yes) &&
246     (tr.SubOptCount >= 2) &&
247     (tr.SubOptBuff[0] == TERMTYPE) &&
248     (tr.SubOptBuff[1] == 1))
249     {
250     _snprintf_s(TmpStr, sizeof(TmpStr), _TRUNCATE, "%c%c%c%c%s%c%c",
251     IAC, SB, TERMTYPE, 0, ts.TermType, IAC, SE);
252     // 4 �o�C�g���� 0 �����������A������������������
253     i = strlen(TmpStr + 4) + 4;
254 doda 6961 CommRawOut(&cv, TmpStr, i);
255 maya 3227
256 doda 6961 if (tr.LogFile)
257     TelWriteLog(TmpStr, i);
258 doda 6959 }
259     else if ( /* (tr.HisOpt[NAWS].Status == Yes) && */
260     (tr.SubOptCount >= 5) &&
261     (tr.SubOptBuff[0] == NAWS))
262     {
263     tr.WinSize.x = tr.SubOptBuff[1]*256+ tr.SubOptBuff[2];
264     tr.WinSize.y = tr.SubOptBuff[3]*256+ tr.SubOptBuff[4];
265     tr.ChangeWinSize = TRUE;
266     }
267 doda 6960 else if ((tr.MyOpt[TERMSPEED].Status == Yes) &&
268     (tr.SubOptCount >= 2) &&
269     (tr.SubOptBuff[0] == TERMSPEED) &&
270     (tr.SubOptBuff[1] == 1))
271     {
272     _snprintf_s(TmpStr, sizeof(TmpStr),
273 doda 6961 _TRUNCATE, "%c%c%c%c%d,%d%c%c",
274 doda 6960 IAC, SB, TERMSPEED, 0,
275     ts.TerminalInputSpeed,
276     ts.TerminalOutputSpeed,
277 doda 6961 IAC, SE);
278 doda 6960 // 4 �o�C�g���� 0 �����������A������������������
279     i = strlen(TmpStr + 4) + 4;
280     CommRawOut(&cv, TmpStr, i);
281    
282     if (tr.LogFile)
283     TelWriteLog(TmpStr, i);
284     }
285 doda 6959 tr.SubOptCount = 0;
286     TelStatus = TelIdle;
287     return ;
288     /* case IAC: braek; */
289     default:
290     if (tr.SubOptCount >= sizeof(tr.SubOptBuff)-1) {
291     tr.SubOptCount = 0;
292     TelStatus = TelIdle;
293     return;
294     }
295     else {
296     tr.SubOptBuff[tr.SubOptCount] = IAC;
297     tr.SubOptCount++;
298     if (b==IAC) {
299     tr.SubOptIAC = TRUE;
300     return;
301     }
302     }
303     }
304 maya 3227 }
305 doda 6959 else if (b==IAC) {
306     tr.SubOptIAC = TRUE;
307     return;
308 maya 3227 }
309 doda 6959
310     if (tr.SubOptCount >= sizeof(tr.SubOptBuff)-1) {
311     tr.SubOptCount = 0;
312     tr.SubOptIAC = FALSE;
313     TelStatus = TelIdle;
314 maya 3227 }
315     else {
316 doda 6959 tr.SubOptBuff[tr.SubOptCount] = b;
317     tr.SubOptCount++;
318 maya 3227 }
319     }
320    
321     void ParseTelWill(BYTE b)
322     {
323 doda 6961 if (b <= MaxTelOpt) {
324     switch (tr.HisOpt[b].Status) {
325     case No:
326     if (tr.HisOpt[b].Accept) {
327     SendBack(DOTEL, b);
328     tr.HisOpt[b].Status = Yes;
329     }
330     else {
331     SendBack(DONTTEL, b);
332     }
333     break;
334 doda 6435
335 doda 6961 case WantNo:
336     switch (tr.HisOpt[b].Que) {
337     case Empty:
338     tr.HisOpt[b].Status = No;
339     break;
340     case Opposite:
341     tr.HisOpt[b].Status = Yes;
342     break;
343     }
344     break;
345 maya 3227
346 doda 6961 case WantYes:
347     switch (tr.HisOpt[b].Que) {
348     case Empty:
349     tr.HisOpt[b].Status = Yes;
350     break;
351     case Opposite:
352     tr.HisOpt[b].Status = WantNo;
353     tr.HisOpt[b].Que = Empty;
354     SendBack(DONTTEL, b);
355     break;
356     }
357     break;
358     }
359 maya 3227 }
360 doda 6961 else {
361     SendBack(DONTTEL, b);
362     }
363 maya 3227
364 doda 6961 switch (b) {
365     case ECHO:
366     if (ts.TelEcho) {
367     switch (tr.HisOpt[ECHO].Status) {
368     case Yes:
369     ts.LocalEcho = 0;
370     break;
371     case No:
372     ts.LocalEcho = 1;
373     break;
374     }
375     }
376     if (tr.HisOpt[ECHO].Status == Yes) {
377     cv.TelLineMode = FALSE;
378     }
379     break;
380    
381     case SGA:
382     if (tr.HisOpt[SGA].Status == Yes) {
383     cv.TelLineMode = FALSE;
384     }
385     break;
386    
387     case BINARY:
388     switch (tr.HisOpt[BINARY].Status) {
389     case Yes:
390     cv.TelBinRecv = TRUE;
391     break;
392     case No:
393     cv.TelBinRecv = FALSE;
394     break;
395     }
396     break;
397 maya 3227 }
398 doda 6961 TelStatus = TelIdle;
399 maya 3227 }
400    
401     void ParseTelWont(BYTE b)
402     {
403 doda 6961 if (b <= MaxTelOpt) {
404     switch (tr.HisOpt[b].Status) {
405     case Yes:
406     tr.HisOpt[b].Status = No;
407     SendBack(DONTTEL, b);
408     break;
409 maya 3227
410 doda 6961 case WantNo:
411     switch (tr.HisOpt[b].Que) {
412     case Empty:
413     tr.HisOpt[b].Status = No;
414     break;
415     case Opposite:
416     tr.HisOpt[b].Status = WantYes;
417     tr.HisOpt[b].Que = Empty;
418     SendBack(DOTEL, b);
419     break;
420     }
421     break;
422 maya 3227
423 doda 6961 case WantYes:
424     switch (tr.HisOpt[b].Que) {
425     case Empty:
426     tr.HisOpt[b].Status = No;
427     break;
428     case Opposite:
429     tr.HisOpt[b].Status = No;
430     tr.HisOpt[b].Que = Empty;
431     break;
432     }
433     break;
434     }
435 maya 3227 }
436 doda 6961 else {
437     SendBack(DONTTEL, b);
438     }
439 maya 3227
440 doda 6961 switch (b) {
441     case ECHO:
442     if (ts.TelEcho) {
443     switch (tr.HisOpt[ECHO].Status) {
444     case Yes:
445     ts.LocalEcho = 0;
446     break;
447     case No:
448     ts.LocalEcho = 1;
449     break;
450     }
451     }
452     if (tr.HisOpt[ECHO].Status == Yes) {
453     cv.TelLineMode = FALSE;
454     }
455     break;
456    
457     case BINARY:
458     switch (tr.HisOpt[BINARY].Status) {
459     case Yes:
460     cv.TelBinRecv = TRUE;
461     break;
462     case No:
463     cv.TelBinRecv = FALSE;
464     break;
465     }
466     break;
467 maya 3227 }
468 doda 6961 TelStatus = TelIdle;
469 maya 3227 }
470    
471     void ParseTelDo(BYTE b)
472     {
473 doda 6961 if (b <= MaxTelOpt) {
474     switch (tr.MyOpt[b].Status) {
475     case No:
476     if (tr.MyOpt[b].Accept) {
477     tr.MyOpt[b].Status = Yes;
478     SendBack(WILLTEL, b);
479     }
480     else {
481     SendBack(WONTTEL, b);
482     }
483     break;
484 maya 3227
485 doda 6961 case WantNo:
486     switch (tr.MyOpt[b].Que) {
487     case Empty:
488     tr.MyOpt[b].Status = No;
489     break;
490     case Opposite:
491     tr.MyOpt[b].Status = Yes;
492     break;
493     }
494     break;
495    
496     case WantYes:
497     switch (tr.MyOpt[b].Que) {
498     case Empty:
499     tr.MyOpt[b].Status = Yes;
500     break;
501     case Opposite:
502     tr.MyOpt[b].Status = WantNo;
503     tr.MyOpt[b].Que = Empty;
504     SendBack(WONTTEL, b);
505     break;
506     }
507     break;
508     }
509 maya 3227 }
510 doda 6961 else {
511     SendBack(WONTTEL, b);
512     }
513 maya 3227
514 doda 6961 switch (b) {
515     case BINARY:
516     switch (tr.MyOpt[BINARY].Status) {
517     case Yes:
518     cv.TelBinSend = TRUE;
519     break;
520     case No:
521     cv.TelBinSend = FALSE;
522     break;
523     }
524     break;
525    
526     case NAWS:
527     if (tr.MyOpt[NAWS].Status==Yes)
528     SendWinSize();
529     break;
530    
531     case SGA:
532     if (tr.MyOpt[SGA].Status==Yes)
533     cv.TelLineMode = FALSE;
534     break;
535 maya 3227 }
536 doda 6961 TelStatus = TelIdle;
537 maya 3227 }
538    
539     void ParseTelDont(BYTE b)
540     {
541 doda 6961 if (b <= MaxTelOpt) {
542     switch (tr.MyOpt[b].Status) {
543     case Yes:
544     tr.MyOpt[b].Status = No;
545     SendBack(WONTTEL, b);
546     break;
547 maya 3227
548 doda 6961 case WantNo:
549     switch (tr.MyOpt[b].Que) {
550     case Empty:
551     tr.MyOpt[b].Status = No;
552     break;
553     case Opposite:
554     tr.MyOpt[b].Status = WantYes;
555     tr.MyOpt[b].Que = Empty;
556     SendBack(WILLTEL, b);
557     break;
558     }
559     break;
560    
561     case WantYes:
562     switch (tr.MyOpt[b].Que) {
563     case Empty:
564     tr.MyOpt[b].Status = No;
565     break;
566     case Opposite:
567     tr.MyOpt[b].Status = No;
568     tr.MyOpt[b].Que = Empty;
569     break;
570     }
571     break;
572     }
573 maya 3227 }
574 doda 6961 else {
575     SendBack(WONTTEL, b);
576     }
577 maya 3227
578 doda 6961 switch (b) {
579     case BINARY:
580     switch (tr.MyOpt[BINARY].Status) {
581     case Yes:
582     cv.TelBinSend = TRUE;
583     break;
584     case No:
585     cv.TelBinSend = FALSE;
586     break;
587     }
588     break;
589 maya 3227 }
590 doda 6961 TelStatus = TelIdle;
591 maya 3227 }
592    
593     void ParseTel(BOOL *Size, int *nx, int *ny)
594     {
595 doda 6961 BYTE b;
596     int c;
597 maya 3227
598 doda 6961 c = CommReadRawByte(&cv, &b);
599 maya 3227
600 doda 6961 while ((c>0) && (cv.TelMode)) {
601     if (tr.LogFile) {
602     if (TelStatus==TelIAC) {
603     _lwrite(tr.LogFile, "\015\012<", 3);
604     TelWriteLog1(0xff);
605     }
606     TelWriteLog1(b);
607     }
608 maya 3227
609 doda 6961 tr.ChangeWinSize = FALSE;
610 maya 3227
611 doda 6961 switch (TelStatus) {
612     case TelIAC: ParseTelIAC(b); break;
613     case TelSB: ParseTelSB(b); break;
614     case TelWill: ParseTelWill(b); break;
615     case TelWont: ParseTelWont(b); break;
616     case TelDo: ParseTelDo(b); break;
617     case TelDont: ParseTelDont(b); break;
618     case TelNop: TelStatus = TelIdle; break;
619     }
620     if (TelStatus == TelIdle) cv.TelMode = FALSE;
621 maya 3227
622 doda 6961 if (cv.TelMode) c = CommReadRawByte(&cv, &b);
623     }
624 maya 3227
625 doda 6961 *Size = tr.ChangeWinSize;
626     *nx = tr.WinSize.x;
627     *ny = tr.WinSize.x;
628 maya 3227 }
629    
630     void TelEnableHisOpt(BYTE b)
631     {
632 doda 6961 if (b <= MaxTelOpt) {
633     switch (tr.HisOpt[b].Status) {
634     case No:
635     tr.HisOpt[b].Status = WantYes;
636     SendBack(DOTEL, b);
637     break;
638 maya 3227
639 doda 6961 case WantNo:
640     if (tr.HisOpt[b].Que==Empty)
641     tr.HisOpt[b].Que = Opposite;
642     break;
643 maya 3227
644 doda 6961 case WantYes:
645     if (tr.HisOpt[b].Que==Opposite)
646     tr.HisOpt[b].Que = Empty;
647     break;
648     }
649     }
650 maya 3227 }
651    
652     void TelDisableHisOpt(BYTE b)
653     {
654 doda 6961 if (b <= MaxTelOpt) {
655     switch (tr.HisOpt[b].Status) {
656     case Yes:
657     tr.HisOpt[b].Status = WantNo;
658     SendBack(DONTTEL, b);
659     break;
660 maya 3227
661 doda 6961 case WantNo:
662     if (tr.HisOpt[b].Que==Opposite)
663     tr.HisOpt[b].Que = Empty;
664     break;
665 maya 3227
666 doda 6961 case WantYes:
667     if (tr.HisOpt[b].Que==Empty)
668     tr.HisOpt[b].Que = Opposite;
669     break;
670     }
671     }
672 maya 3227 }
673    
674     void TelEnableMyOpt(BYTE b)
675     {
676 doda 6961 if (b <= MaxTelOpt) {
677     switch (tr.MyOpt[b].Status) {
678     case No:
679     tr.MyOpt[b].Status = WantYes;
680     SendBack(WILLTEL, b);
681     break;
682 maya 3227
683 doda 6961 case WantNo:
684     if (tr.MyOpt[b].Que==Empty)
685     tr.MyOpt[b].Que = Opposite;
686     break;
687 maya 3227
688 doda 6961 case WantYes:
689     if (tr.MyOpt[b].Que==Opposite)
690     tr.MyOpt[b].Que = Empty;
691     break;
692     }
693     }
694 maya 3227 }
695    
696     void TelDisableMyOpt(BYTE b)
697     {
698 doda 6961 if (b <= MaxTelOpt) {
699     switch (tr.MyOpt[b].Status) {
700     case Yes:
701     tr.MyOpt[b].Status = WantNo;
702     SendBack(WONTTEL, b);
703     break;
704 maya 3227
705 doda 6961 case WantNo:
706     if (tr.MyOpt[b].Que==Opposite)
707     tr.MyOpt[b].Que = Empty;
708     break;
709 maya 3227
710 doda 6961 case WantYes:
711     if (tr.MyOpt[b].Que==Empty)
712     tr.MyOpt[b].Que = Opposite;
713     break;
714     }
715     }
716 maya 3227 }
717    
718     void TelInformWinSize(int nx, int ny)
719     {
720 doda 6961 if ((tr.MyOpt[NAWS].Status==Yes) &&
721     (nx != tr.WinSize.x || ny != tr.WinSize.y))
722     {
723     tr.WinSize.x = nx;
724     tr.WinSize.y = ny;
725     SendWinSize();
726     }
727 maya 3227 }
728    
729     void TelSendAYT()
730     {
731 doda 6961 BYTE Str[2];
732 maya 3227
733 doda 6961 Str[0] = IAC;
734     Str[1] = AYT;
735     CommRawOut(&cv, Str, 2);
736     CommSend(&cv);
737     if (tr.LogFile)
738     TelWriteLog(Str, 2);
739 maya 3227 }
740    
741     void TelSendBreak()
742     {
743 doda 6961 BYTE Str[2];
744 maya 3227
745 doda 6961 Str[0] = IAC;
746     Str[1] = BREAK;
747     CommRawOut(&cv, Str, 2);
748     CommSend(&cv);
749     if (tr.LogFile)
750     TelWriteLog(Str, 2);
751 maya 3227 }
752    
753     void TelChangeEcho()
754     {
755 doda 6961 if (ts.LocalEcho==0)
756     TelEnableHisOpt(ECHO);
757     else
758     TelDisableHisOpt(ECHO);
759 maya 3227 }
760    
761     void TelSendNOP()
762     {
763 doda 6961 BYTE Str[2];
764 maya 3227
765 doda 6961 Str[0] = IAC;
766     Str[1] = NOP;
767     CommRawOut(&cv, Str, 2);
768     CommSend(&cv);
769     if (tr.LogFile)
770     TelWriteLog(Str, 2);
771 maya 3227 }
772    
773     #define WM_SEND_HEARTBEAT (WM_USER + 1)
774    
775     static LRESULT CALLBACK telnet_heartbeat_dlg_proc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
776     {
777     switch (msg) {
778 doda 6961 case WM_INITDIALOG:
779     return FALSE;
780 maya 3227
781 doda 6961 case WM_SEND_HEARTBEAT:
782     TelSendNOP();
783     return TRUE;
784     break;
785 maya 3227
786 doda 6961 case WM_COMMAND:
787     switch (LOWORD(wp)) {
788     case IDOK:
789 maya 3227 return TRUE;
790 doda 6961 case IDCANCEL:
791     EndDialog(hWnd, 0);
792 maya 3227 return TRUE;
793     default:
794     return FALSE;
795 doda 6961 }
796     break;
797    
798     case WM_CLOSE:
799     // close�{�^���������������� window ���������������������B
800     return TRUE;
801    
802     case WM_DESTROY:
803     return TRUE;
804    
805     default:
806     return FALSE;
807 maya 3227 }
808     return TRUE;
809     }
810    
811    
812     static unsigned _stdcall TelKeepAliveThread(void *dummy) {
813 doda 6961 static int instance = 0;
814 maya 3227
815 doda 6961 if (instance > 0)
816     return 0;
817     instance++;
818 maya 3227
819 doda 6961 while (cv.Open && nop_interval > 0) {
820     if (time(NULL) >= cv.LastSendTime + nop_interval) {
821     SendMessage(keepalive_dialog, WM_SEND_HEARTBEAT, 0, 0);
822     }
823 maya 3227
824 doda 6961 Sleep(100);
825     }
826     instance--;
827     return 0;
828 maya 3227 }
829    
830     void TelStartKeepAliveThread() {
831 doda 6961 unsigned tid;
832 maya 3227
833 doda 6961 if (ts.TelKeepAliveInterval > 0) {
834     nop_interval = ts.TelKeepAliveInterval;
835 maya 3227
836     // ���[�h���X�_�C�A���O������ (2007.12.26 yutaka)
837     keepalive_dialog = CreateDialog(hInst, MAKEINTRESOURCE(IDD_BROADCAST_DIALOG),
838 doda 6961 HVTWin, (DLGPROC)telnet_heartbeat_dlg_proc);
839 maya 3227
840 doda 6961 keepalive_thread = (HANDLE)_beginthreadex(NULL, 0, TelKeepAliveThread, NULL, 0, &tid);
841     if (keepalive_thread == (HANDLE)-1) {
842     nop_interval = 0;
843     }
844     }
845 maya 3227 }
846    
847     void TelStopKeepAliveThread() {
848 doda 6961 if (keepalive_thread != (HANDLE)-1L) {
849     nop_interval = 0;
850     WaitForSingleObject(keepalive_thread, INFINITE);
851     CloseHandle(keepalive_thread);
852     keepalive_thread = (HANDLE)-1L;
853 maya 3227
854 doda 6961 DestroyWindow(keepalive_dialog);
855     }
856 maya 3227 }
857    
858     void TelUpdateKeepAliveInterval() {
859 doda 6961 if (cv.Open && cv.TelFlag && ts.TCPPort==ts.TelPort) {
860     if (ts.TelKeepAliveInterval > 0 && keepalive_thread == (HANDLE)-1)
861     TelStartKeepAliveThread();
862     else if (ts.TelKeepAliveInterval == 0 && keepalive_thread != (HANDLE)-1)
863     TelStopKeepAliveThread();
864     else
865     nop_interval = ts.TelKeepAliveInterval;
866     }
867 maya 3227 }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help