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