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