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 3530 - (hide annotations) (download) (as text)
Mon Jun 22 04:59:08 2009 UTC (14 years, 9 months ago) by doda
File MIME type: text/x-csrc
File size: 15690 byte(s) 
相手側からのSGA要求でも行単位送信モードを無効にするようにした。

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