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 9365 - (hide annotations) (download) (as text)
Sun Aug 15 13:13:46 2021 UTC (2 years, 7 months ago) by zmatsuo
File MIME type: text/x-csrc
File size: 17945 byte(s) 
変数、関数をstaticにし変更した

- nop_interval
- TelSendNOP()
- TelStopKeepAliveThread()
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     }
399 maya 3227 }
400 doda 6961 else {
401     SendBack(DONTTEL, b);
402     }
403 maya 3227
404 doda 6961 switch (b) {
405     case ECHO:
406     if (ts.TelEcho) {
407     switch (tr.HisOpt[ECHO].Status) {
408     case Yes:
409     ts.LocalEcho = 0;
410     break;
411     case No:
412     ts.LocalEcho = 1;
413     break;
414     }
415     }
416     if (tr.HisOpt[ECHO].Status == Yes) {
417     cv.TelLineMode = FALSE;
418     }
419     break;
420    
421     case SGA:
422     if (tr.HisOpt[SGA].Status == Yes) {
423     cv.TelLineMode = FALSE;
424     }
425     break;
426    
427     case BINARY:
428     switch (tr.HisOpt[BINARY].Status) {
429     case Yes:
430     cv.TelBinRecv = TRUE;
431     break;
432     case No:
433     cv.TelBinRecv = FALSE;
434     break;
435     }
436     break;
437 maya 3227 }
438 doda 6961 TelStatus = TelIdle;
439 maya 3227 }
440    
441     void ParseTelWont(BYTE b)
442     {
443 doda 6961 if (b <= MaxTelOpt) {
444     switch (tr.HisOpt[b].Status) {
445     case Yes:
446     tr.HisOpt[b].Status = No;
447     SendBack(DONTTEL, b);
448     break;
449 maya 3227
450 doda 6961 case WantNo:
451     switch (tr.HisOpt[b].Que) {
452     case Empty:
453     tr.HisOpt[b].Status = No;
454     break;
455     case Opposite:
456     tr.HisOpt[b].Status = WantYes;
457     tr.HisOpt[b].Que = Empty;
458     SendBack(DOTEL, b);
459     break;
460     }
461     break;
462 maya 3227
463 doda 6961 case WantYes:
464     switch (tr.HisOpt[b].Que) {
465     case Empty:
466     tr.HisOpt[b].Status = No;
467     break;
468     case Opposite:
469     tr.HisOpt[b].Status = No;
470     tr.HisOpt[b].Que = Empty;
471     break;
472     }
473     break;
474     }
475 maya 3227 }
476 doda 6961 else {
477     SendBack(DONTTEL, b);
478     }
479 maya 3227
480 doda 6961 switch (b) {
481     case ECHO:
482     if (ts.TelEcho) {
483     switch (tr.HisOpt[ECHO].Status) {
484     case Yes:
485     ts.LocalEcho = 0;
486     break;
487     case No:
488     ts.LocalEcho = 1;
489     break;
490     }
491     }
492     if (tr.HisOpt[ECHO].Status == Yes) {
493     cv.TelLineMode = FALSE;
494     }
495     break;
496    
497     case BINARY:
498     switch (tr.HisOpt[BINARY].Status) {
499     case Yes:
500     cv.TelBinRecv = TRUE;
501     break;
502     case No:
503     cv.TelBinRecv = FALSE;
504     break;
505     }
506     break;
507 maya 3227 }
508 doda 6961 TelStatus = TelIdle;
509 maya 3227 }
510    
511     void ParseTelDo(BYTE b)
512     {
513 doda 6961 if (b <= MaxTelOpt) {
514     switch (tr.MyOpt[b].Status) {
515     case No:
516     if (tr.MyOpt[b].Accept) {
517     tr.MyOpt[b].Status = Yes;
518     SendBack(WILLTEL, b);
519     }
520     else {
521     SendBack(WONTTEL, b);
522     }
523     break;
524 maya 3227
525 doda 6961 case WantNo:
526     switch (tr.MyOpt[b].Que) {
527     case Empty:
528     tr.MyOpt[b].Status = No;
529     break;
530     case Opposite:
531     tr.MyOpt[b].Status = Yes;
532     break;
533     }
534     break;
535    
536     case WantYes:
537     switch (tr.MyOpt[b].Que) {
538     case Empty:
539     tr.MyOpt[b].Status = Yes;
540     break;
541     case Opposite:
542     tr.MyOpt[b].Status = WantNo;
543     tr.MyOpt[b].Que = Empty;
544     SendBack(WONTTEL, b);
545     break;
546     }
547     break;
548     }
549 maya 3227 }
550 doda 6961 else {
551     SendBack(WONTTEL, b);
552     }
553 maya 3227
554 doda 6961 switch (b) {
555     case BINARY:
556     switch (tr.MyOpt[BINARY].Status) {
557     case Yes:
558     cv.TelBinSend = TRUE;
559     break;
560     case No:
561     cv.TelBinSend = FALSE;
562     break;
563     }
564     break;
565    
566     case NAWS:
567     if (tr.MyOpt[NAWS].Status==Yes)
568     SendWinSize();
569     break;
570    
571     case SGA:
572     if (tr.MyOpt[SGA].Status==Yes)
573     cv.TelLineMode = FALSE;
574     break;
575 maya 3227 }
576 doda 6961 TelStatus = TelIdle;
577 maya 3227 }
578    
579     void ParseTelDont(BYTE b)
580     {
581 doda 6961 if (b <= MaxTelOpt) {
582     switch (tr.MyOpt[b].Status) {
583     case Yes:
584     tr.MyOpt[b].Status = No;
585     SendBack(WONTTEL, b);
586     break;
587 maya 3227
588 doda 6961 case WantNo:
589     switch (tr.MyOpt[b].Que) {
590     case Empty:
591     tr.MyOpt[b].Status = No;
592     break;
593     case Opposite:
594     tr.MyOpt[b].Status = WantYes;
595     tr.MyOpt[b].Que = Empty;
596     SendBack(WILLTEL, b);
597     break;
598     }
599     break;
600    
601     case WantYes:
602     switch (tr.MyOpt[b].Que) {
603     case Empty:
604     tr.MyOpt[b].Status = No;
605     break;
606     case Opposite:
607     tr.MyOpt[b].Status = No;
608     tr.MyOpt[b].Que = Empty;
609     break;
610     }
611     break;
612     }
613 maya 3227 }
614 doda 6961 else {
615     SendBack(WONTTEL, b);
616     }
617 maya 3227
618 doda 6961 switch (b) {
619     case BINARY:
620     switch (tr.MyOpt[BINARY].Status) {
621     case Yes:
622     cv.TelBinSend = TRUE;
623     break;
624     case No:
625     cv.TelBinSend = FALSE;
626     break;
627     }
628     break;
629 maya 3227 }
630 doda 6961 TelStatus = TelIdle;
631 maya 3227 }
632    
633     void ParseTel(BOOL *Size, int *nx, int *ny)
634     {
635 doda 6961 BYTE b;
636     int c;
637 maya 3227
638 doda 6961 c = CommReadRawByte(&cv, &b);
639 maya 3227
640 doda 6961 while ((c>0) && (cv.TelMode)) {
641     if (tr.LogFile) {
642     if (TelStatus==TelIAC) {
643 zmatsuo 9364 win16_lwrite(tr.LogFile, "\015\012<", 3);
644 doda 6961 TelWriteLog1(0xff);
645     }
646     TelWriteLog1(b);
647     }
648 maya 3227
649 doda 6961 tr.ChangeWinSize = FALSE;
650 maya 3227
651 doda 6961 switch (TelStatus) {
652     case TelIAC: ParseTelIAC(b); break;
653     case TelSB: ParseTelSB(b); break;
654     case TelWill: ParseTelWill(b); break;
655     case TelWont: ParseTelWont(b); break;
656     case TelDo: ParseTelDo(b); break;
657     case TelDont: ParseTelDont(b); break;
658     case TelNop: TelStatus = TelIdle; break;
659     }
660     if (TelStatus == TelIdle) cv.TelMode = FALSE;
661 maya 3227
662 doda 6961 if (cv.TelMode) c = CommReadRawByte(&cv, &b);
663     }
664 maya 3227
665 doda 6961 *Size = tr.ChangeWinSize;
666     *nx = tr.WinSize.x;
667     *ny = tr.WinSize.x;
668 maya 3227 }
669    
670     void TelEnableHisOpt(BYTE b)
671     {
672 doda 6961 if (b <= MaxTelOpt) {
673     switch (tr.HisOpt[b].Status) {
674     case No:
675     tr.HisOpt[b].Status = WantYes;
676     SendBack(DOTEL, b);
677     break;
678 maya 3227
679 doda 6961 case WantNo:
680     if (tr.HisOpt[b].Que==Empty)
681     tr.HisOpt[b].Que = Opposite;
682     break;
683 maya 3227
684 doda 6961 case WantYes:
685     if (tr.HisOpt[b].Que==Opposite)
686     tr.HisOpt[b].Que = Empty;
687     break;
688     }
689     }
690 maya 3227 }
691    
692     void TelDisableHisOpt(BYTE b)
693     {
694 doda 6961 if (b <= MaxTelOpt) {
695     switch (tr.HisOpt[b].Status) {
696     case Yes:
697     tr.HisOpt[b].Status = WantNo;
698     SendBack(DONTTEL, b);
699     break;
700 maya 3227
701 doda 6961 case WantNo:
702     if (tr.HisOpt[b].Que==Opposite)
703     tr.HisOpt[b].Que = Empty;
704     break;
705 maya 3227
706 doda 6961 case WantYes:
707     if (tr.HisOpt[b].Que==Empty)
708     tr.HisOpt[b].Que = Opposite;
709     break;
710     }
711     }
712 maya 3227 }
713    
714     void TelEnableMyOpt(BYTE b)
715     {
716 doda 6961 if (b <= MaxTelOpt) {
717     switch (tr.MyOpt[b].Status) {
718     case No:
719     tr.MyOpt[b].Status = WantYes;
720     SendBack(WILLTEL, b);
721     break;
722 maya 3227
723 doda 6961 case WantNo:
724     if (tr.MyOpt[b].Que==Empty)
725     tr.MyOpt[b].Que = Opposite;
726     break;
727 maya 3227
728 doda 6961 case WantYes:
729     if (tr.MyOpt[b].Que==Opposite)
730     tr.MyOpt[b].Que = Empty;
731     break;
732     }
733     }
734 maya 3227 }
735    
736     void TelDisableMyOpt(BYTE b)
737     {
738 doda 6961 if (b <= MaxTelOpt) {
739     switch (tr.MyOpt[b].Status) {
740     case Yes:
741     tr.MyOpt[b].Status = WantNo;
742     SendBack(WONTTEL, b);
743     break;
744 maya 3227
745 doda 6961 case WantNo:
746     if (tr.MyOpt[b].Que==Opposite)
747     tr.MyOpt[b].Que = Empty;
748     break;
749 maya 3227
750 doda 6961 case WantYes:
751     if (tr.MyOpt[b].Que==Empty)
752     tr.MyOpt[b].Que = Opposite;
753     break;
754     }
755     }
756 maya 3227 }
757    
758     void TelInformWinSize(int nx, int ny)
759     {
760 doda 6961 if ((tr.MyOpt[NAWS].Status==Yes) &&
761     (nx != tr.WinSize.x || ny != tr.WinSize.y))
762     {
763     tr.WinSize.x = nx;
764     tr.WinSize.y = ny;
765     SendWinSize();
766     }
767 maya 3227 }
768    
769     void TelSendAYT()
770     {
771 doda 6961 BYTE Str[2];
772 maya 3227
773 doda 6961 Str[0] = IAC;
774     Str[1] = AYT;
775     CommRawOut(&cv, Str, 2);
776     CommSend(&cv);
777     if (tr.LogFile)
778     TelWriteLog(Str, 2);
779 maya 3227 }
780    
781     void TelSendBreak()
782     {
783 doda 6961 BYTE Str[2];
784 maya 3227
785 doda 6961 Str[0] = IAC;
786     Str[1] = BREAK;
787     CommRawOut(&cv, Str, 2);
788     CommSend(&cv);
789     if (tr.LogFile)
790     TelWriteLog(Str, 2);
791 maya 3227 }
792    
793     void TelChangeEcho()
794     {
795 doda 6961 if (ts.LocalEcho==0)
796     TelEnableHisOpt(ECHO);
797     else
798     TelDisableHisOpt(ECHO);
799 maya 3227 }
800    
801 zmatsuo 9365 static void TelSendNOP()
802 maya 3227 {
803 doda 6961 BYTE Str[2];
804 maya 3227
805 doda 6961 Str[0] = IAC;
806     Str[1] = NOP;
807     CommRawOut(&cv, Str, 2);
808     CommSend(&cv);
809     if (tr.LogFile)
810     TelWriteLog(Str, 2);
811 maya 3227 }
812    
813     #define WM_SEND_HEARTBEAT (WM_USER + 1)
814    
815 zmatsuo 7930 static INT_PTR CALLBACK telnet_heartbeat_dlg_proc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
816 maya 3227 {
817     switch (msg) {
818 doda 6961 case WM_INITDIALOG:
819     return FALSE;
820 maya 3227
821 doda 6961 case WM_SEND_HEARTBEAT:
822     TelSendNOP();
823     return TRUE;
824     break;
825 maya 3227
826 doda 6961 case WM_COMMAND:
827     switch (LOWORD(wp)) {
828     case IDOK:
829 maya 3227 return TRUE;
830 doda 6961 case IDCANCEL:
831     EndDialog(hWnd, 0);
832 maya 3227 return TRUE;
833     default:
834     return FALSE;
835 doda 6961 }
836     break;
837    
838     case WM_CLOSE:
839     // close�{�^���������������� window ���������������������B
840     return TRUE;
841    
842     case WM_DESTROY:
843     return TRUE;
844    
845     default:
846     return FALSE;
847 maya 3227 }
848     return TRUE;
849     }
850    
851    
852     static unsigned _stdcall TelKeepAliveThread(void *dummy) {
853 doda 6961 static int instance = 0;
854 maya 3227
855 doda 6961 if (instance > 0)
856     return 0;
857     instance++;
858 maya 3227
859 doda 6961 while (cv.Open && nop_interval > 0) {
860     if (time(NULL) >= cv.LastSendTime + nop_interval) {
861     SendMessage(keepalive_dialog, WM_SEND_HEARTBEAT, 0, 0);
862     }
863 maya 3227
864 doda 6961 Sleep(100);
865     }
866     instance--;
867     return 0;
868 maya 3227 }
869    
870     void TelStartKeepAliveThread() {
871 doda 6961 unsigned tid;
872 maya 3227
873 doda 6961 if (ts.TelKeepAliveInterval > 0) {
874     nop_interval = ts.TelKeepAliveInterval;
875 maya 3227
876 zmatsuo 7930 // ���[�h���X�_�C�A���O������ (2007.12.26 yutaka)
877     keepalive_dialog = CreateDialog(hInst, MAKEINTRESOURCE(IDD_BROADCAST_DIALOG),
878     HVTWin, telnet_heartbeat_dlg_proc);
879 maya 3227
880 doda 6961 keepalive_thread = (HANDLE)_beginthreadex(NULL, 0, TelKeepAliveThread, NULL, 0, &tid);
881 zmatsuo 7931 if (keepalive_thread == 0) {
882     keepalive_thread = INVALID_HANDLE_VALUE;
883 doda 6961 nop_interval = 0;
884     }
885     }
886 maya 3227 }
887    
888 zmatsuo 9365 static void TelStopKeepAliveThread() {
889 zmatsuo 7930 if (keepalive_thread != INVALID_HANDLE_VALUE) {
890 doda 6961 nop_interval = 0;
891     WaitForSingleObject(keepalive_thread, INFINITE);
892     CloseHandle(keepalive_thread);
893 zmatsuo 7930 keepalive_thread = INVALID_HANDLE_VALUE;
894 maya 3227
895 doda 6961 DestroyWindow(keepalive_dialog);
896     }
897 maya 3227 }
898    
899     void TelUpdateKeepAliveInterval() {
900 doda 6961 if (cv.Open && cv.TelFlag && ts.TCPPort==ts.TelPort) {
901 zmatsuo 7930 if (ts.TelKeepAliveInterval > 0 && keepalive_thread == INVALID_HANDLE_VALUE)
902 doda 6961 TelStartKeepAliveThread();
903 zmatsuo 7930 else if (ts.TelKeepAliveInterval == 0 && keepalive_thread != INVALID_HANDLE_VALUE)
904 doda 6961 TelStopKeepAliveThread();
905     else
906     nop_interval = ts.TelKeepAliveInterval;
907     }
908 maya 3227 }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help