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 9364 - (hide annotations) (download) (as text)
Sun Aug 15 13:13:34 2021 UTC (2 years, 7 months ago) by zmatsuo
File MIME type: text/x-csrc
File size: 17856 byte(s) 
telnet.c で win16api.c の関数を使用しないようにした

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