Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/branches/ttcomtester/teraterm/teraterm/telnet.c

Annotation of /branches/ttcomtester/teraterm/teraterm/telnet.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 9366 - (hide annotations) (download) (as text)
Sun Aug 15 13:13:58 2021 UTC (2 years, 7 months ago) by zmatsuo
Original Path: trunk/teraterm/teraterm/telnet.c
File MIME type: text/x-csrc
File size: 18379 byte(s) 
switch に default: を追加

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