Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/branches/ssh_chacha20poly1305/ttssh2/ttxssh/ttxssh.c

Annotation of /branches/ssh_chacha20poly1305/ttssh2/ttxssh/ttxssh.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 6508 - (hide annotations) (download) (as text)
Thu Oct 20 12:51:47 2016 UTC (7 years, 5 months ago) by yutakapon
Original Path: trunk/ttssh2/ttxssh/ttxssh.c
File MIME type: text/x-csrc
File size: 187005 byte(s) 
チケット #36709 SSH認証ダイアログのrhostsのローカルユーザ名にゴミが表示される

teraterm.iniのTTSSHのOrder読み込み処理において、メモリ破壊が発生することがある
問題を修正した。
1 maya 3227 /*
2     Copyright (c) 1998-2001, Robert O'Callahan
3     All rights reserved.
4    
5     Redistribution and use in source and binary forms, with or without modification,
6     are permitted provided that the following conditions are met:
7    
8     Redistributions of source code must retain the above copyright notice, this list of
9     conditions and the following disclaimer.
10    
11     Redistributions in binary form must reproduce the above copyright notice, this list
12     of conditions and the following disclaimer in the documentation and/or other materials
13     provided with the distribution.
14    
15     The name of Robert O'Callahan may not be used to endorse or promote products derived from
16     this software without specific prior written permission.
17    
18     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
19     ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20     OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21     THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22     EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23     SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
25     OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26     SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27     */
28    
29     /* Tera Term extension mechanism
30     Robert O'Callahan (roc+tt@cs.cmu.edu)
31    
32     Tera Term by Takashi Teranishi (teranishi@rikaxp.riken.go.jp)
33     */
34    
35     #include "ttxssh.h"
36     #include "fwdui.h"
37     #include "util.h"
38     #include "ssh.h"
39     #include "ttcommon.h"
40 r850 3298 #include "ttlib.h"
41 yutakapon 5545 #include "keyfiles.h"
42 doda 6250 #include "arc4random.h"
43 maya 3227
44     #include <stdlib.h>
45     #include <stdio.h>
46     #include <string.h>
47     #include <io.h>
48     #include <fcntl.h>
49     #include <sys/stat.h>
50     #include <time.h>
51 doda 3232 #include <mbstring.h>
52 maya 3227
53     #include "resource.h"
54     #include <commctrl.h>
55     #include <commdlg.h>
56     #ifndef NO_INET6
57     #include <winsock2.h>
58     static char FAR *ProtocolFamilyList[] = { "UNSPEC", "IPv6", "IPv4", NULL };
59     #else
60     #include <winsock.h>
61     #endif /* NO_INET6 */
62    
63     #include <Lmcons.h>
64    
65     // include OpenSSL header file
66     #include <openssl/evp.h>
67     #include <openssl/rsa.h>
68     #include <openssl/dsa.h>
69     #include <openssl/bn.h>
70     #include <openssl/pem.h>
71     #include <openssl/rand.h>
72     #include <openssl/rc4.h>
73     #include <openssl/md5.h>
74    
75     // include ZLib header file
76     #include <zlib.h>
77    
78     #include "buffer.h"
79     #include "cipher.h"
80 maya 4321 #include "key.h"
81 maya 3227
82     #include "sftp.h"
83    
84     #include "compat_w95.h"
85    
86 yutakapon 4533 #include "puttyversion.h"
87    
88 maya 3227 #define MATCH_STR(s, o) strncmp((s), (o), NUM_ELEM(o) - 1)
89     #define MATCH_STR_I(s, o) _strnicmp((s), (o), NUM_ELEM(o) - 1)
90    
91     /* This extension implements SSH, so we choose a load order in the
92     "protocols" range. */
93     #define ORDER 2500
94    
95     static HICON SecureLargeIcon = NULL;
96     static HICON SecureSmallIcon = NULL;
97    
98     static HFONT DlgHostFont;
99     static HFONT DlgAboutFont;
100 yutakapon 5578 static HFONT DlgAboutTextFont;
101 maya 3227 static HFONT DlgSetupFont;
102     static HFONT DlgKeygenFont;
103    
104     static TInstVar FAR *pvar;
105    
106     typedef struct {
107 maya 4307 int cnt;
108     HWND dlg;
109 maya 4378 ssh_keytype type;
110 maya 3227 } cbarg_t;
111    
112     /* WIN32 allows multiple instances of a DLL */
113     static TInstVar InstVar;
114    
115     /*
116     This code makes lots of assumptions about the order in which Tera Term
117     does things, and how. A key assumption is that the Notification window
118     passed into WSAAsyncSelect is the main terminal window. We also assume
119     that the socket used in the first WSAconnect is the main session socket.
120     */
121    
122     static void init_TTSSH(PTInstVar pvar)
123     {
124     pvar->socket = INVALID_SOCKET;
125     pvar->OldLargeIcon = NULL;
126     pvar->OldSmallIcon = NULL;
127     pvar->NotificationWindow = NULL;
128     pvar->hostdlg_activated = FALSE;
129     pvar->socket = INVALID_SOCKET;
130     pvar->NotificationWindow = NULL;
131     pvar->protocol_major = 0;
132     pvar->protocol_minor = 0;
133    
134     PKT_init(pvar);
135     SSH_init(pvar);
136     CRYPT_init(pvar);
137     AUTH_init(pvar);
138     HOSTS_init(pvar);
139     FWD_init(pvar);
140     FWDUI_init(pvar);
141    
142     ssh_heartbeat_lock_initialize();
143     }
144    
145     static void uninit_TTSSH(PTInstVar pvar)
146     {
147     halt_ssh_heartbeat_thread(pvar);
148    
149     ssh2_channel_free();
150    
151     SSH_end(pvar);
152     PKT_end(pvar);
153     AUTH_end(pvar);
154     CRYPT_end(pvar);
155     HOSTS_end(pvar);
156     FWD_end(pvar);
157     FWDUI_end(pvar);
158    
159     if (pvar->OldLargeIcon != NULL) {
160     PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_BIG,
161     (LPARAM) pvar->OldLargeIcon);
162     pvar->OldLargeIcon = NULL;
163     }
164     if (pvar->OldSmallIcon != NULL) {
165     PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_SMALL,
166     (LPARAM) pvar->OldSmallIcon);
167     pvar->OldSmallIcon = NULL;
168     }
169    
170     ssh_heartbeat_lock_finalize();
171     }
172    
173     static void PASCAL FAR TTXInit(PTTSet ts, PComVar cv)
174     {
175     pvar->settings = *pvar->ts_SSH;
176     pvar->ts = ts;
177     pvar->cv = cv;
178     pvar->fatal_error = FALSE;
179     pvar->showing_err = FALSE;
180     pvar->err_msg = NULL;
181    
182     init_TTSSH(pvar);
183     }
184    
185 maya 4378 static void normalize_generic_order(char *buf, char default_strings[], int default_strings_len)
186     {
187     char listed[max(KEX_DH_MAX,max(SSH_CIPHER_MAX,max(KEY_MAX,max(HMAC_MAX,COMP_MAX)))) + 1];
188     char allowed[max(KEX_DH_MAX,max(SSH_CIPHER_MAX,max(KEY_MAX,max(HMAC_MAX,COMP_MAX)))) + 1];
189 maya 6031 int i, j, k=-1;
190 maya 4378
191     memset(listed, 0, sizeof(listed));
192     memset(allowed, 0, sizeof(allowed));
193 yutakapon 6508
194     // �����������������������X�g�������B
195 maya 4378 for (i = 0; i < default_strings_len ; i++) {
196     allowed[default_strings[i]] = 1;
197     }
198    
199 yutakapon 6508 // �w�����������������������A���������������������A�d���������������������B
200     //
201     // ex. (i=5 ����������������)
202     // i=012345
203     // >:=9<87;A@?B3026(\0)
204     // i+1
205     // <------------>
206     // ��
207     // >:=9<7;A@?B3026(\0)
208     //
209 maya 4378 for (i = 0; buf[i] != 0; i++) {
210     int num = buf[i] - '0';
211    
212     if (num < 0 || num > default_strings_len
213     || !allowed[num]
214     || listed[num]) {
215     memmove(buf + i, buf + i + 1, strlen(buf + i + 1) + 1);
216     i--;
217     } else {
218     listed[num] = 1;
219     }
220 maya 6031
221 yutakapon 6508 // disabled line���������A���u���o���������B
222 maya 6031 if (num == 0) {
223     k = i;
224     }
225 maya 4378 }
226    
227 maya 6031 #if 1
228 yutakapon 6508 // �w���������������������������Adisabled line�����O���}�������B
229     //
230     // ex. (Z���}������)
231     // k
232     // >:=9<87;A@?B3026(\0)
233     // k+1
234     // <---->
235     // �� k
236     // >:=9<87;A@?B30026(\0)
237     // �� k
238     // >:=9<87;A@?B3Z026(\0)
239     //
240 maya 6031 for (j = 0; j < default_strings_len && default_strings[j] != 0; j++) {
241     int num = default_strings[j];
242    
243     if (!listed[num] && k >= 0) {
244 yutakapon 6508 int copylen = strlen(buf + k + 1) + 1;
245    
246     memmove(buf + k + 1, buf + k, copylen);
247     buf[k + 1 + copylen] = '\0'; // �I�[���Y�������t�����B
248 maya 6031 buf[k] = num + '0';
249     k++;
250     i++;
251     }
252     }
253     if (k < 0) {
254     j = 0;
255     }
256     else {
257     j++;
258     }
259 yutakapon 6508
260     // disabled line�������������������A�����������������������B
261 maya 6031 for (; j < default_strings_len ; j++) {
262     int num = default_strings[j];
263    
264     if (!listed[num]) {
265     buf[i] = num + '0';
266     i++;
267     }
268     }
269     #else
270 maya 4378 for (j = 0; j < default_strings_len ; j++) {
271     int num = default_strings[j];
272    
273     if (!listed[num]) {
274     buf[i] = num + '0';
275     i++;
276     }
277     }
278 maya 6031 #endif
279 maya 4378
280     buf[i] = 0;
281     }
282    
283 maya 3227 /*
284     * Remove unsupported cipher or duplicated cipher.
285     * Add unspecified ciphers at the end of list.
286     */
287     static void normalize_cipher_order(char FAR * buf)
288     {
289     /* SSH_CIPHER_NONE means that all ciphers below that one are disabled.
290     We *never* allow no encryption. */
291     #if 0
292 maya 4378 static char default_strings[] = {
293 maya 3227 SSH_CIPHER_3DES,
294     SSH_CIPHER_NONE,
295     SSH_CIPHER_DES, SSH_CIPHER_BLOWFISH
296     };
297     #else
298     // for SSH2(yutaka)
299 maya 4378 static char default_strings[] = {
300 doda 4433 SSH2_CIPHER_CAMELLIA256_CTR,
301 maya 3227 SSH2_CIPHER_AES256_CTR,
302 doda 4433 SSH2_CIPHER_CAMELLIA256_CBC,
303 maya 3227 SSH2_CIPHER_AES256_CBC,
304 doda 4433 SSH2_CIPHER_CAMELLIA192_CTR,
305 maya 3227 SSH2_CIPHER_AES192_CTR,
306 doda 4433 SSH2_CIPHER_CAMELLIA192_CBC,
307 maya 3227 SSH2_CIPHER_AES192_CBC,
308 doda 4433 SSH2_CIPHER_CAMELLIA128_CTR,
309 maya 3227 SSH2_CIPHER_AES128_CTR,
310 doda 4433 SSH2_CIPHER_CAMELLIA128_CBC,
311 maya 3227 SSH2_CIPHER_AES128_CBC,
312 doda 3850 SSH2_CIPHER_3DES_CTR,
313 maya 3227 SSH2_CIPHER_3DES_CBC,
314 doda 3850 SSH2_CIPHER_BLOWFISH_CTR,
315 maya 3227 SSH2_CIPHER_BLOWFISH_CBC,
316 doda 3850 SSH2_CIPHER_CAST128_CTR,
317 maya 3227 SSH2_CIPHER_CAST128_CBC,
318     SSH_CIPHER_3DES,
319     SSH_CIPHER_NONE,
320 maya 5917 SSH2_CIPHER_ARCFOUR256,
321     SSH2_CIPHER_ARCFOUR128,
322     SSH2_CIPHER_ARCFOUR,
323     SSH_CIPHER_BLOWFISH,
324 maya 3227 SSH_CIPHER_DES,
325 maya 4432 0, 0, 0 // Dummy for SSH_CIPHER_IDEA, SSH_CIPHER_TSS, SSH_CIPHER_RC4
326 maya 3227 };
327     #endif
328    
329 maya 4378 normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
330 maya 3227 }
331    
332 yutakapon 4367 static void normalize_kex_order(char FAR * buf)
333     {
334     static char default_strings[] = {
335     KEX_ECDH_SHA2_256,
336     KEX_ECDH_SHA2_384,
337     KEX_ECDH_SHA2_521,
338 doda 6310 KEX_DH_GRP18_SHA512,
339     KEX_DH_GRP16_SHA512,
340 doda 6263 KEX_DH_GRP14_SHA256,
341 yutakapon 4367 KEX_DH_GEX_SHA256,
342     KEX_DH_GEX_SHA1,
343     KEX_DH_GRP14_SHA1,
344     KEX_DH_GRP1_SHA1,
345     KEX_DH_NONE,
346     };
347    
348     normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
349     }
350    
351     static void normalize_host_key_order(char FAR * buf)
352     {
353     static char default_strings[] = {
354     KEY_ECDSA256,
355     KEY_ECDSA384,
356     KEY_ECDSA521,
357 yutakapon 5545 KEY_ED25519,
358 yutakapon 4367 KEY_RSA,
359     KEY_DSA,
360     KEY_NONE,
361     };
362    
363     normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
364     }
365    
366     static void normalize_mac_order(char FAR * buf)
367     {
368     static char default_strings[] = {
369 doda 4434 HMAC_SHA2_512,
370     HMAC_SHA2_256,
371 yutakapon 4367 HMAC_SHA1,
372 doda 4423 HMAC_RIPEMD160,
373 yutakapon 4367 HMAC_MD5,
374 doda 4426 HMAC_NONE,
375 doda 4434 HMAC_SHA1_96,
376     HMAC_MD5_96,
377 doda 5016 0, // Dummy for HMAC_SHA2_512_96,
378     0, // Dummy for HMAC_SHA2_256_96,
379 yutakapon 4367 };
380    
381     normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
382     }
383    
384     static void normalize_comp_order(char FAR * buf)
385     {
386     static char default_strings[] = {
387 doda 4371 COMP_DELAYED,
388     COMP_ZLIB,
389 maya 4378 COMP_NOCOMP,
390 yutakapon 4367 COMP_NONE,
391     };
392    
393     normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
394     }
395    
396    
397 maya 3227 /* Remove local settings from the shared memory block. */
398     static void clear_local_settings(PTInstVar pvar)
399     {
400     pvar->ts_SSH->TryDefaultAuth = FALSE;
401     }
402    
403     static BOOL read_BOOL_option(PCHAR fileName, char FAR * keyName, BOOL def)
404     {
405     char buf[1024];
406    
407     buf[0] = 0;
408     GetPrivateProfileString("TTSSH", keyName, "", buf, sizeof(buf),
409     fileName);
410     if (buf[0] == 0) {
411     return def;
412     } else {
413     return atoi(buf) != 0 ||
414     _stricmp(buf, "yes") == 0 ||
415     _stricmp(buf, "y") == 0;
416     }
417     }
418    
419     static void read_string_option(PCHAR fileName, char FAR * keyName,
420     char FAR * def, char FAR * buf, int bufSize)
421     {
422    
423     buf[0] = 0;
424     GetPrivateProfileString("TTSSH", keyName, def, buf, bufSize, fileName);
425     }
426    
427     static void read_ssh_options(PTInstVar pvar, PCHAR fileName)
428     {
429     char buf[1024];
430     TS_SSH FAR *settings = pvar->ts_SSH;
431    
432     #define READ_STD_STRING_OPTION(name) \
433     read_string_option(fileName, #name, "", settings->name, sizeof(settings->name))
434    
435     settings->Enabled = read_BOOL_option(fileName, "Enabled", FALSE);
436    
437     buf[0] = 0;
438     GetPrivateProfileString("TTSSH", "Compression", "", buf, sizeof(buf),
439     fileName);
440     settings->CompressionLevel = atoi(buf);
441     if (settings->CompressionLevel < 0 || settings->CompressionLevel > 9) {
442     settings->CompressionLevel = 0;
443     }
444    
445     READ_STD_STRING_OPTION(DefaultUserName);
446     READ_STD_STRING_OPTION(DefaultForwarding);
447     READ_STD_STRING_OPTION(DefaultRhostsLocalUserName);
448     READ_STD_STRING_OPTION(DefaultRhostsHostPrivateKeyFile);
449     READ_STD_STRING_OPTION(DefaultRSAPrivateKeyFile);
450    
451     READ_STD_STRING_OPTION(CipherOrder);
452     normalize_cipher_order(settings->CipherOrder);
453    
454 yutakapon 4367 // KEX order
455     READ_STD_STRING_OPTION(KexOrder);
456     normalize_kex_order(settings->KexOrder);
457     // Host Key algorithm order
458     READ_STD_STRING_OPTION(HostKeyOrder);
459     normalize_host_key_order(settings->HostKeyOrder);
460     // H-MAC order
461     READ_STD_STRING_OPTION(MacOrder);
462     normalize_mac_order(settings->MacOrder);
463     // Compression algorithm order
464     READ_STD_STRING_OPTION(CompOrder);
465     normalize_comp_order(settings->CompOrder);
466    
467 maya 3227 read_string_option(fileName, "KnownHostsFiles", "ssh_known_hosts",
468     settings->KnownHostsFiles,
469     sizeof(settings->KnownHostsFiles));
470    
471     buf[0] = 0;
472     GetPrivateProfileString("TTSSH", "DefaultAuthMethod", "", buf,
473     sizeof(buf), fileName);
474     settings->DefaultAuthMethod = atoi(buf);
475     if (settings->DefaultAuthMethod != SSH_AUTH_PASSWORD
476     && settings->DefaultAuthMethod != SSH_AUTH_RSA
477     && settings->DefaultAuthMethod != SSH_AUTH_TIS // add (2005.3.12 yutaka)
478     && settings->DefaultAuthMethod != SSH_AUTH_RHOSTS
479     && settings->DefaultAuthMethod != SSH_AUTH_PAGEANT) {
480     /* this default can never be SSH_AUTH_RHOSTS_RSA because that is not a
481     selection in the dialog box; SSH_AUTH_RHOSTS_RSA is automatically chosen
482     when the dialog box has rhosts selected and an host private key file
483     is supplied. */
484     settings->DefaultAuthMethod = SSH_AUTH_PASSWORD;
485     }
486    
487     buf[0] = 0;
488     GetPrivateProfileString("TTSSH", "LogLevel", "", buf, sizeof(buf),
489     fileName);
490     settings->LogLevel = atoi(buf);
491    
492     buf[0] = 0;
493     GetPrivateProfileString("TTSSH", "WriteBufferSize", "", buf,
494     sizeof(buf), fileName);
495     settings->WriteBufferSize = atoi(buf);
496     if (settings->WriteBufferSize <= 0) {
497     settings->WriteBufferSize = (PACKET_MAX_SIZE / 2); // 2MB
498     }
499    
500     // SSH protocol version (2004.10.11 yutaka)
501     // default is SSH2 (2004.11.30 yutaka)
502     settings->ssh_protocol_version = GetPrivateProfileInt("TTSSH", "ProtocolVersion", 2, fileName);
503    
504     // SSH heartbeat time(second) (2004.12.11 yutaka)
505     settings->ssh_heartbeat_overtime = GetPrivateProfileInt("TTSSH", "HeartBeat", 60, fileName);
506    
507     // �p�X���[�h�F�����������J���F�����g���p�X���[�h����������������������������������
508     // �\���B(2006.8.5 yutaka)
509     settings->remember_password = GetPrivateProfileInt("TTSSH", "RememberPassword", 1, fileName);
510    
511     // �������F���_�C�A���O���T�|�[�g�������������\�b�h���`�F�b�N���A
512     // ���������\�b�h���O���C�A�E�g���� (2007.9.24 maya)
513     settings->CheckAuthListFirst = read_BOOL_option(fileName, "CheckAuthListFirst", FALSE);
514    
515     // 768bit ������ RSA ���������T�[�o�����������L�������� (2008.9.11 maya)
516     settings->EnableRsaShortKeyServer = read_BOOL_option(fileName, "EnableRsaShortKeyServer", FALSE);
517    
518     // agent forward ���L�������� (2008.11.25 maya)
519     settings->ForwardAgent = read_BOOL_option(fileName, "ForwardAgent", FALSE);
520    
521 maya 4229 // agent forward �m�F���L��������
522     settings->ForwardAgentConfirm = read_BOOL_option(fileName, "ForwardAgentConfirm", TRUE);
523    
524 doda 4531 // �z�X�g���� DNS �����`�F�b�N (RFC 4255)
525 doda 4619 settings->VerifyHostKeyDNS = read_BOOL_option(fileName, "VerifyHostKeyDNS", TRUE);
526 doda 4531
527 doda 5261 // icon
528     GetPrivateProfileString("TTSSH", "SSHIcon", "", buf, sizeof(buf), fileName);
529     if ((_stricmp(buf, "old") == 0) ||
530     (_stricmp(buf, "yellow") == 0) ||
531     (_stricmp(buf, "securett_yellow") == 0)) {
532     settings->IconID = IDI_SECURETT_YELLOW;
533     }
534 maya 6386 else if ((_stricmp(buf, "green") == 0) ||
535     (_stricmp(buf, "securett_green") == 0)) {
536     settings->IconID = IDI_SECURETT_GREEN;
537     }
538 doda 5261 else {
539     settings->IconID = IDI_SECURETT;
540     }
541    
542 yutakapon 5620 // �G���[�������x�������|�b�v�A�b�v���b�Z�[�W���}�~���� (2014.6.26 yutaka)
543     settings->DisablePopupMessage = GetPrivateProfileInt("TTSSH", "DisablePopupMessage", 0, fileName);
544    
545 doda 5793 READ_STD_STRING_OPTION(X11Display);
546    
547 yutakapon 5849 settings->UpdateHostkeys = GetPrivateProfileInt("TTSSH", "UpdateHostkeys", 0, fileName);
548 yutakapon 5839
549 doda 5900 settings->GexMinimalGroupSize = GetPrivateProfileInt("TTSSH", "GexMinimalGroupSize", 0, fileName);
550    
551 maya 3227 clear_local_settings(pvar);
552     }
553    
554     static void write_ssh_options(PTInstVar pvar, PCHAR fileName,
555 maya 5868 TS_SSH FAR * settings, BOOL copy_forward)
556 maya 3227 {
557     char buf[1024];
558    
559     WritePrivateProfileString("TTSSH", "Enabled",
560     settings->Enabled ? "1" : "0", fileName);
561    
562     _itoa(settings->CompressionLevel, buf, 10);
563     WritePrivateProfileString("TTSSH", "Compression", buf, fileName);
564    
565     WritePrivateProfileString("TTSSH", "DefaultUserName",
566     settings->DefaultUserName, fileName);
567    
568     if (copy_forward) {
569     WritePrivateProfileString("TTSSH", "DefaultForwarding",
570 maya 5960 settings->DefaultForwarding, fileName);
571 maya 3227 }
572    
573     WritePrivateProfileString("TTSSH", "CipherOrder",
574     settings->CipherOrder, fileName);
575    
576 yutakapon 4367 WritePrivateProfileString("TTSSH", "KexOrder",
577     settings->KexOrder, fileName);
578    
579     WritePrivateProfileString("TTSSH", "HostKeyOrder",
580     settings->HostKeyOrder, fileName);
581    
582     WritePrivateProfileString("TTSSH", "MacOrder",
583     settings->MacOrder, fileName);
584    
585     WritePrivateProfileString("TTSSH", "CompOrder",
586     settings->CompOrder, fileName);
587    
588 maya 3227 WritePrivateProfileString("TTSSH", "KnownHostsFiles",
589     settings->KnownHostsFiles, fileName);
590    
591     WritePrivateProfileString("TTSSH", "DefaultRhostsLocalUserName",
592     settings->DefaultRhostsLocalUserName,
593     fileName);
594    
595     WritePrivateProfileString("TTSSH", "DefaultRhostsHostPrivateKeyFile",
596     settings->DefaultRhostsHostPrivateKeyFile,
597     fileName);
598    
599     WritePrivateProfileString("TTSSH", "DefaultRSAPrivateKeyFile",
600     settings->DefaultRSAPrivateKeyFile,
601     fileName);
602    
603     _itoa(settings->DefaultAuthMethod, buf, 10);
604     WritePrivateProfileString("TTSSH", "DefaultAuthMethod", buf, fileName);
605    
606     _itoa(settings->LogLevel, buf, 10);
607     WritePrivateProfileString("TTSSH", "LogLevel", buf, fileName);
608    
609     _itoa(settings->WriteBufferSize, buf, 10);
610     WritePrivateProfileString("TTSSH", "WriteBufferSize", buf, fileName);
611    
612     // SSH protocol version (2004.10.11 yutaka)
613     WritePrivateProfileString("TTSSH", "ProtocolVersion",
614     settings->ssh_protocol_version==2 ? "2" : "1",
615     fileName);
616    
617     // SSH heartbeat time(second) (2004.12.11 yutaka)
618     _snprintf_s(buf, sizeof(buf), _TRUNCATE,
619     "%d", settings->ssh_heartbeat_overtime);
620     WritePrivateProfileString("TTSSH", "HeartBeat", buf, fileName);
621    
622     // Remember password (2006.8.5 yutaka)
623     WritePrivateProfileString("TTSSH", "RememberPassword",
624     settings->remember_password ? "1" : "0",
625     fileName);
626    
627     // �������F���_�C�A���O���T�|�[�g�������������\�b�h���`�F�b�N���A
628     // ���������\�b�h���O���C�A�E�g���� (2007.9.24 maya)
629     WritePrivateProfileString("TTSSH", "CheckAuthListFirst",
630     settings->CheckAuthListFirst ? "1" : "0", fileName);
631    
632     // 768bit ������ RSA ���������T�[�o�����������L�������� (2008.9.11 maya)
633     WritePrivateProfileString("TTSSH", "EnableRsaShortKeyServer",
634     settings->EnableRsaShortKeyServer ? "1" : "0", fileName);
635    
636     // agent forward ���L�������� (2008.11.25 maya)
637     WritePrivateProfileString("TTSSH", "ForwardAgent",
638     settings->ForwardAgent ? "1" : "0", fileName);
639 maya 4229
640     // agent forward �m�F���L��������
641     WritePrivateProfileString("TTSSH", "ForwardAgentConfirm",
642     settings->ForwardAgentConfirm ? "1" : "0", fileName);
643 doda 4531
644     // �z�X�g���� DNS �����`�F�b�N (RFC 4255)
645     WritePrivateProfileString("TTSSH", "VerifyHostKeyDNS",
646     settings->VerifyHostKeyDNS ? "1" : "0", fileName);
647 doda 5294
648     // SSH �A�C�R��
649 maya 6386 if (settings->IconID==IDI_SECURETT_YELLOW) {
650     WritePrivateProfileString("TTSSH", "SSHIcon", "yellow", fileName);
651     }
652     else if (settings->IconID==IDI_SECURETT_GREEN) {
653     WritePrivateProfileString("TTSSH", "SSHIcon", "green", fileName);
654     }
655     else {
656     WritePrivateProfileString("TTSSH", "SSHIcon", "Default", fileName);
657     }
658 yutakapon 5620
659     _itoa(settings->DisablePopupMessage, buf, 10);
660     WritePrivateProfileString("TTSSH", "DisablePopupMessage", buf, fileName);
661 doda 5793
662     WritePrivateProfileString("TTSSH", "X11Display", settings->X11Display, fileName);
663 yutakapon 5839
664 yutakapon 5849 _snprintf_s(buf, sizeof(buf), _TRUNCATE,
665     "%d", settings->UpdateHostkeys);
666     WritePrivateProfileString("TTSSH", "UpdateHostkeys", buf, fileName);
667 doda 5900
668     _itoa_s(settings->GexMinimalGroupSize, buf, sizeof(buf), 10);
669     WritePrivateProfileString("TTSSH", "GexMinimalGroupSize", buf, fileName);
670 maya 3227 }
671    
672    
673     /* find free port in all protocol family */
674     static unsigned short find_local_port(PTInstVar pvar)
675     {
676     int tries;
677     #ifndef NO_INET6
678     SOCKET connecter;
679     struct addrinfo hints;
680     struct addrinfo FAR *res;
681     struct addrinfo FAR *res0;
682     unsigned short port;
683     char pname[NI_MAXHOST];
684     #endif /* NO_INET6 */
685    
686     if (pvar->session_settings.DefaultAuthMethod != SSH_AUTH_RHOSTS) {
687     return 0;
688     }
689    
690     /* The random numbers here are only used to try to get fresh
691     ports across runs (dangling ports can cause bind errors
692     if we're unlucky). They do not need to be (and are not)
693     cryptographically strong.
694     */
695     srand((unsigned) GetTickCount());
696    
697     #ifndef NO_INET6
698     for (tries = 20; tries > 0; tries--) {
699     memset(&hints, 0, sizeof(hints));
700     hints.ai_family = pvar->ts->ProtocolFamily;
701     hints.ai_flags = AI_PASSIVE;
702     hints.ai_socktype = SOCK_STREAM;
703     port = (unsigned) rand() % 512 + 512;
704     _snprintf_s(pname, sizeof(pname), _TRUNCATE, "%d", (int) port);
705     if (getaddrinfo(NULL, pname, &hints, &res0)) {
706     return 0;
707     /* NOT REACHED */
708     }
709    
710     for (res = res0; res; res = res->ai_next) {
711     if (res->ai_family == AF_INET || res->ai_family == AF_INET6)
712     continue;
713    
714     connecter =
715     socket(res->ai_family, res->ai_socktype, res->ai_protocol);
716     if (connecter == INVALID_SOCKET) {
717     freeaddrinfo(res0);
718     return 0;
719     }
720    
721     if (bind(connecter, res->ai_addr, res->ai_addrlen) !=
722     SOCKET_ERROR) {
723     return port;
724     freeaddrinfo(res0);
725     closesocket(connecter);
726     } else if (WSAGetLastError() != WSAEADDRINUSE) {
727     closesocket(connecter);
728     freeaddrinfo(res0);
729     return 0;
730     }
731    
732     closesocket(connecter);
733     }
734     freeaddrinfo(res0);
735     }
736    
737     return 0;
738     #else
739     for (tries = 20; tries > 0; tries--) {
740     SOCKET connecter = socket(AF_INET, SOCK_STREAM, 0);
741     struct sockaddr_in connecter_addr;
742    
743     connecter_addr.sin_family = AF_INET;
744     connecter_addr.sin_port = (unsigned) rand() % 512 + 512;
745     connecter_addr.sin_addr.s_addr = htonl(INADDR_ANY);
746    
747     if (connecter == INVALID_SOCKET) {
748     return 0;
749     }
750    
751     if (bind
752     (connecter, (struct sockaddr FAR *) &connecter_addr,
753     sizeof(connecter_addr)) != SOCKET_ERROR) {
754     closesocket(connecter);
755     return connecter_addr.sin_port;
756     } else if (WSAGetLastError() != WSAEADDRINUSE) {
757     closesocket(connecter);
758     return 0;
759     }
760    
761     closesocket(connecter);
762     }
763    
764     return 0;
765     #endif /* NO_INET6 */
766     }
767    
768     static int PASCAL FAR TTXconnect(SOCKET s,
769     const struct sockaddr FAR * name,
770     int namelen)
771     {
772     #ifndef NO_INET6
773 maya 4584 if (pvar->socket == INVALID_SOCKET || pvar->socket != s) {
774 maya 3227 struct sockaddr_storage ss;
775     int len;
776    
777     pvar->socket = s;
778    
779     memset(&ss, 0, sizeof(ss));
780     switch (pvar->ts->ProtocolFamily) {
781     case AF_INET:
782     len = sizeof(struct sockaddr_in);
783     ((struct sockaddr_in FAR *) &ss)->sin_family = AF_INET;
784     ((struct sockaddr_in FAR *) &ss)->sin_addr.s_addr = INADDR_ANY;
785     ((struct sockaddr_in FAR *) &ss)->sin_port =
786     htons(find_local_port(pvar));
787     break;
788     case AF_INET6:
789     len = sizeof(struct sockaddr_in6);
790     ((struct sockaddr_in6 FAR *) &ss)->sin6_family = AF_INET6;
791     #if 0 /* symbol "in6addr_any" is not included in wsock32.lib */
792     /* if wsock32.lib will be linked, we can't refer "in6addr_any" */
793     ((struct sockaddr_in6 FAR *) &ss)->sin6_addr = in6addr_any;
794     #else
795     memset(&((struct sockaddr_in6 FAR *) &ss)->sin6_addr, 0,
796     sizeof(struct in_addr6));
797     #endif /* 0 */
798     ((struct sockaddr_in6 FAR *) &ss)->sin6_port =
799     htons(find_local_port(pvar));
800     break;
801     default:
802 maya 4586 /* UNSPEC */
803 maya 3227 break;
804     }
805    
806     bind(s, (struct sockaddr FAR *) &ss, len);
807     }
808     #else
809     if (pvar->socket == INVALID_SOCKET) {
810     struct sockaddr_in addr;
811    
812     pvar->socket = s;
813    
814     addr.sin_family = AF_INET;
815     addr.sin_port = htons(find_local_port(pvar));
816     addr.sin_addr.s_addr = INADDR_ANY;
817     memset(addr.sin_zero, 0, sizeof(addr.sin_zero));
818    
819     bind(s, (struct sockaddr FAR *) &addr, sizeof(addr));
820     }
821     #endif /* NO_INET6 */
822    
823     return (pvar->Pconnect) (s, name, namelen);
824     }
825    
826     static int PASCAL FAR TTXWSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg,
827     long lEvent)
828     {
829     if (s == pvar->socket) {
830     pvar->notification_events = lEvent;
831     pvar->notification_msg = wMsg;
832    
833     if (pvar->NotificationWindow == NULL) {
834     pvar->NotificationWindow = hWnd;
835     AUTH_advance_to_next_cred(pvar);
836     }
837     }
838    
839     return (pvar->PWSAAsyncSelect) (s, hWnd, wMsg, lEvent);
840     }
841    
842     static int PASCAL FAR TTXrecv(SOCKET s, char FAR * buf, int len, int flags)
843     {
844     if (s == pvar->socket) {
845     int ret;
846    
847     ssh_heartbeat_lock();
848     ret = PKT_recv(pvar, buf, len);
849     ssh_heartbeat_unlock();
850     return (ret);
851    
852     } else {
853     return (pvar->Precv) (s, buf, len, flags);
854     }
855     }
856    
857     static int PASCAL FAR TTXsend(SOCKET s, char const FAR * buf, int len,
858     int flags)
859     {
860     if (s == pvar->socket) {
861     ssh_heartbeat_lock();
862     SSH_send(pvar, buf, len);
863     ssh_heartbeat_unlock();
864     return len;
865     } else {
866     return (pvar->Psend) (s, buf, len, flags);
867     }
868     }
869    
870     void notify_established_secure_connection(PTInstVar pvar)
871     {
872     int fuLoad = LR_DEFAULTCOLOR;
873    
874 yutakapon 6286 if (IsWindowsNT4()) {
875 maya 3227 fuLoad = LR_VGACOLOR;
876     }
877    
878     // LoadIcon �������� LoadImage ���g�����������A
879     // 16x16 ���A�C�R���������I�������������������� (2006.8.9 maya)
880     if (SecureLargeIcon == NULL) {
881 doda 5261 SecureLargeIcon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
882 maya 3227 IMAGE_ICON, 0, 0, fuLoad);
883     }
884     if (SecureSmallIcon == NULL) {
885 doda 5261 SecureSmallIcon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
886 maya 3227 IMAGE_ICON, 16, 16, fuLoad);
887     }
888    
889     if (SecureLargeIcon != NULL && SecureSmallIcon != NULL) {
890 maya 3454 #if 0
891 maya 3227 // �������A�C�R���� WNDCLASS ���Z�b�g�����������������o���������� (2006.8.10 maya)
892     pvar->OldLargeIcon =
893     (HICON) GetClassLong(pvar->NotificationWindow, GCL_HICON);
894 maya 3454 #else
895     // Tera Term ���� WM_SETICON �������������������������������o�� (2009.6.9 maya)
896     pvar->OldLargeIcon =
897     (HICON) SendMessage(pvar->NotificationWindow, WM_GETICON,
898     ICON_BIG, 0);
899     #endif
900 maya 3227 pvar->OldSmallIcon =
901     (HICON) SendMessage(pvar->NotificationWindow, WM_GETICON,
902     ICON_SMALL, 0);
903    
904     PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_BIG,
905     (LPARAM) SecureLargeIcon);
906     PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_SMALL,
907     (LPARAM) SecureSmallIcon);
908     }
909    
910     notify_verbose_message(pvar, "Entering secure mode",
911     LOG_LEVEL_VERBOSE);
912     }
913    
914 maya 5678 void notify_closed_connection(PTInstVar pvar, char FAR * send_msg)
915 maya 3227 {
916 maya 5678 SSH_notify_disconnecting(pvar, send_msg);
917 maya 3227 AUTH_notify_disconnecting(pvar);
918     HOSTS_notify_disconnecting(pvar);
919    
920     PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
921     pvar->socket, MAKELPARAM(FD_CLOSE, 0));
922     }
923    
924     static void add_err_msg(PTInstVar pvar, char FAR * msg)
925     {
926     if (pvar->err_msg != NULL) {
927     int buf_len = strlen(pvar->err_msg) + 3 + strlen(msg);
928     char FAR *buf = (char FAR *) malloc(buf_len);
929    
930     strncpy_s(buf, buf_len, pvar->err_msg, _TRUNCATE);
931     strncat_s(buf, buf_len, "\n\n", _TRUNCATE);
932     strncat_s(buf, buf_len, msg, _TRUNCATE);
933     free(pvar->err_msg);
934     pvar->err_msg = buf;
935     } else {
936     pvar->err_msg = _strdup(msg);
937     }
938     }
939    
940     void notify_nonfatal_error(PTInstVar pvar, char FAR * msg)
941     {
942     if (!pvar->showing_err) {
943     // �������������������m���E�B���h�E�����������A�f�X�N�g�b�v���I�[�i�[������
944     // ���b�Z�[�W�{�b�N�X���o���������B(2006.6.11 yutaka)
945     if (pvar->NotificationWindow == NULL) {
946     UTIL_get_lang_msg("MSG_ERROR_NONFAITAL", pvar,
947     "Tera Term: not fatal error");
948     MessageBox(NULL, msg, pvar->ts->UIMsg, MB_OK|MB_ICONINFORMATION);
949     msg[0] = '\0';
950    
951     } else {
952     PostMessage(pvar->NotificationWindow, WM_COMMAND,
953     ID_SSHASYNCMESSAGEBOX, 0);
954     }
955     }
956     if (msg[0] != 0) {
957     notify_verbose_message(pvar, msg, LOG_LEVEL_ERROR);
958     add_err_msg(pvar, msg);
959     }
960     }
961    
962 maya 5678 void notify_fatal_error(PTInstVar pvar, char FAR * msg, BOOL send_disconnect)
963 maya 3227 {
964     if (msg[0] != 0) {
965     notify_verbose_message(pvar, msg, LOG_LEVEL_FATAL);
966     add_err_msg(pvar, msg);
967     }
968    
969     if (!pvar->fatal_error) {
970     pvar->fatal_error = TRUE;
971    
972 maya 5678 if (send_disconnect) {
973     SSH_notify_disconnecting(pvar, msg);
974     }
975 maya 3227 AUTH_notify_disconnecting(pvar);
976     HOSTS_notify_disconnecting(pvar);
977    
978     PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
979     pvar->socket, MAKELPARAM(FD_CLOSE,
980     (pvar->PWSAGetLastError) ()));
981     }
982     }
983    
984     void notify_verbose_message(PTInstVar pvar, char FAR * msg, int level)
985     {
986     if (level <= pvar->session_settings.LogLevel) {
987     char buf[1024];
988     int file;
989    
990     get_teraterm_dir_relative_name(buf, NUM_ELEM(buf), "TTSSH.LOG");
991     file = _open(buf, _O_RDWR | _O_APPEND | _O_CREAT | _O_TEXT,
992     _S_IREAD | _S_IWRITE);
993    
994     if (file >= 0) {
995 maya 4551 char *strtime = mctimelocal();
996 maya 4546 DWORD processid;
997 maya 3227 char tmp[26];
998 maya 4546
999     _write(file, strtime, strlen(strtime));
1000 maya 3227 GetWindowThreadProcessId(pvar->cv->HWin, &processid);
1001     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, " [%lu] ",processid);
1002     _write(file, tmp, strlen(tmp));
1003     _write(file, msg, strlen(msg));
1004     _write(file, "\n", 1);
1005     _close(file);
1006     }
1007     }
1008     }
1009    
1010 doda 6051 void logprintf(PTInstVar pvar, int level, char *fmt, ...)
1011     {
1012     char buff[4096];
1013     va_list params;
1014    
1015     if (level <= pvar->session_settings.LogLevel) {
1016     va_start(params, fmt);
1017     vsnprintf_s(buff, sizeof(buff), _TRUNCATE, fmt, params);
1018     va_end(params);
1019    
1020     notify_verbose_message(pvar, buff, level);
1021     }
1022     }
1023    
1024 yutakapon 6302 static void format_line_hexdump(char *buf, int buflen, int addr, int *bytes, int byte_cnt)
1025     {
1026     int i, c;
1027     char tmp[128];
1028    
1029     buf[0] = 0;
1030    
1031     /* �������A�h���X�\�� */
1032     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "%08X : ", addr);
1033     strncat_s(buf, buflen, tmp, _TRUNCATE);
1034    
1035     /* �o�C�i���\���i4�o�C�g�������������}���j*/
1036     for (i = 0; i < byte_cnt; i++) {
1037     if (i > 0 && i % 4 == 0) {
1038     strncat_s(buf, buflen, " ", _TRUNCATE);
1039     }
1040    
1041     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "%02X", bytes[i]);
1042     strncat_s(buf, buflen, tmp, _TRUNCATE);
1043     }
1044    
1045     /* ASCII�\���������������������� */
1046     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, " %*s%*s", (16 - byte_cnt) * 2 + 1, " ", (16 - byte_cnt + 3) / 4, " ");
1047     strncat_s(buf, buflen, tmp, _TRUNCATE);
1048    
1049     /* ASCII�\�� */
1050     for (i = 0; i < byte_cnt; i++) {
1051     c = bytes[i];
1052     if (isprint(c)) {
1053     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "%c", c);
1054     strncat_s(buf, buflen, tmp, _TRUNCATE);
1055     }
1056     else {
1057     strncat_s(buf, buflen, ".", _TRUNCATE);
1058     }
1059     }
1060    
1061     //strncat_s(buf, buflen, "\n", _TRUNCATE);
1062     }
1063    
1064     void logprintf_hexdump(PTInstVar pvar, int level, char *data, int len, char *fmt, ...)
1065     {
1066     char buff[4096];
1067     va_list params;
1068     int c, addr;
1069     int bytes[16], *ptr;
1070     int byte_cnt;
1071     int i;
1072    
1073     if (level <= pvar->session_settings.LogLevel) {
1074     va_start(params, fmt);
1075     vsnprintf_s(buff, sizeof(buff), _TRUNCATE, fmt, params);
1076     va_end(params);
1077    
1078     notify_verbose_message(pvar, buff, level);
1079    
1080     addr = 0;
1081     byte_cnt = 0;
1082     ptr = bytes;
1083     for (i = 0; i < len; i++) {
1084     c = data[i];
1085     *ptr++ = c & 0xff;
1086     byte_cnt++;
1087    
1088     if (byte_cnt == 16) {
1089     format_line_hexdump(buff, sizeof(buff), addr, bytes, byte_cnt);
1090     notify_verbose_message(pvar, buff, level);
1091    
1092     addr += 16;
1093     byte_cnt = 0;
1094     ptr = bytes;
1095     }
1096     }
1097    
1098     if (byte_cnt > 0) {
1099     format_line_hexdump(buff, sizeof(buff), addr, bytes, byte_cnt);
1100     notify_verbose_message(pvar, buff, level);
1101     }
1102     }
1103     }
1104    
1105 maya 3227 static void PASCAL FAR TTXOpenTCP(TTXSockHooks FAR * hooks)
1106     {
1107     if (pvar->settings.Enabled) {
1108     // TCPLocalEcho/TCPCRSend ������������ (maya 2007.4.25)
1109 doda 3579 pvar->origDisableTCPEchoCR = pvar->ts->DisableTCPEchoCR;
1110 maya 3227 pvar->ts->DisableTCPEchoCR = TRUE;
1111    
1112     pvar->session_settings = pvar->settings;
1113    
1114     notify_verbose_message(pvar, "---------------------------------------------------------------------", LOG_LEVEL_VERBOSE);
1115     notify_verbose_message(pvar, "Initiating SSH session", LOG_LEVEL_VERBOSE);
1116    
1117     FWDUI_load_settings(pvar);
1118    
1119     pvar->cv->TelAutoDetect = FALSE;
1120     /* This next line should not be needed because Tera Term's
1121     CommLib should find ts->Telnet == 0 ... but we'll do this
1122     just to be on the safe side. */
1123     pvar->cv->TelFlag = FALSE;
1124 doda 3495 pvar->cv->TelLineMode = FALSE;
1125 maya 3227
1126     pvar->Precv = *hooks->Precv;
1127     pvar->Psend = *hooks->Psend;
1128     pvar->PWSAAsyncSelect = *hooks->PWSAAsyncSelect;
1129     pvar->Pconnect = *hooks->Pconnect;
1130     pvar->PWSAGetLastError = *hooks->PWSAGetLastError;
1131    
1132     *hooks->Precv = TTXrecv;
1133     *hooks->Psend = TTXsend;
1134     *hooks->PWSAAsyncSelect = TTXWSAAsyncSelect;
1135     *hooks->Pconnect = TTXconnect;
1136    
1137     SSH_open(pvar);
1138     HOSTS_open(pvar);
1139     FWDUI_open(pvar);
1140    
1141     // ������ myproposal �����f���������A�������O�����������B (2006.6.26 maya)
1142     SSH2_update_cipher_myproposal(pvar);
1143 yutakapon 4367 SSH2_update_kex_myproposal(pvar);
1144     SSH2_update_host_key_myproposal(pvar);
1145     SSH2_update_hmac_myproposal(pvar);
1146 maya 3227 SSH2_update_compression_myproposal(pvar);
1147     }
1148     }
1149    
1150     static void PASCAL FAR TTXCloseTCP(TTXSockHooks FAR * hooks)
1151     {
1152     if (pvar->session_settings.Enabled) {
1153     pvar->socket = INVALID_SOCKET;
1154    
1155     notify_verbose_message(pvar, "Terminating SSH session...",
1156     LOG_LEVEL_VERBOSE);
1157    
1158     *hooks->Precv = pvar->Precv;
1159     *hooks->Psend = pvar->Psend;
1160     *hooks->PWSAAsyncSelect = pvar->PWSAAsyncSelect;
1161     *hooks->Pconnect = pvar->Pconnect;
1162 doda 3579
1163     pvar->ts->DisableTCPEchoCR = pvar->origDisableTCPEchoCR;
1164 maya 3227 }
1165    
1166     uninit_TTSSH(pvar);
1167     init_TTSSH(pvar);
1168     }
1169    
1170     static void enable_dlg_items(HWND dlg, int from, int to, BOOL enabled)
1171     {
1172     for (; from <= to; from++) {
1173     EnableWindow(GetDlgItem(dlg, from), enabled);
1174     }
1175     }
1176    
1177     // C-p/C-n/C-b/C-f/C-a/C-e ���T�|�[�g (2007.9.5 maya)
1178     // C-d/C-k ���T�|�[�g (2007.10.3 yutaka)
1179     // �h���b�v�_�E���������G�f�B�b�g�R���g���[����
1180     // �T�u�N���X�������������E�C���h�E�v���V�[�W��
1181     WNDPROC OrigHostnameEditProc; // Original window procedure
1182     LRESULT CALLBACK HostnameEditProc(HWND dlg, UINT msg,
1183 maya 5868 WPARAM wParam, LPARAM lParam)
1184 maya 3227 {
1185     HWND parent;
1186     int max, select, len;
1187     char *str, *orgstr;
1188    
1189     switch (msg) {
1190     // �L�[�����������������m����
1191     case WM_KEYDOWN:
1192     if (GetKeyState(VK_CONTROL) < 0) {
1193     switch (wParam) {
1194     case 0x50: // Ctrl+p ... up
1195     parent = GetParent(dlg);
1196     select = SendMessage(parent, CB_GETCURSEL, 0, 0);
1197     if (select > 0) {
1198     PostMessage(parent, CB_SETCURSEL, select - 1, 0);
1199     }
1200     return 0;
1201     case 0x4e: // Ctrl+n ... down
1202     parent = GetParent(dlg);
1203     max = SendMessage(parent, CB_GETCOUNT, 0, 0);
1204     select = SendMessage(parent, CB_GETCURSEL, 0, 0);
1205     if (select < max - 1) {
1206     PostMessage(parent, CB_SETCURSEL, select + 1, 0);
1207     }
1208     return 0;
1209     case 0x42: // Ctrl+b ... left
1210     SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
1211     PostMessage(dlg, EM_SETSEL, select-1, select-1);
1212     return 0;
1213     case 0x46: // Ctrl+f ... right
1214     SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
1215     max = GetWindowTextLength(dlg) ;
1216     PostMessage(dlg, EM_SETSEL, select+1, select+1);
1217     return 0;
1218     case 0x41: // Ctrl+a ... home
1219     PostMessage(dlg, EM_SETSEL, 0, 0);
1220     return 0;
1221     case 0x45: // Ctrl+e ... end
1222     max = GetWindowTextLength(dlg) ;
1223     PostMessage(dlg, EM_SETSEL, max, max);
1224     return 0;
1225    
1226     case 0x44: // Ctrl+d
1227     case 0x4b: // Ctrl+k
1228     case 0x55: // Ctrl+u
1229     SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
1230     max = GetWindowTextLength(dlg);
1231     max++; // '\0'
1232     orgstr = str = malloc(max);
1233     if (str != NULL) {
1234     len = GetWindowText(dlg, str, max);
1235     if (select >= 0 && select < len) {
1236     if (wParam == 0x44) { // �J�[�\���z����������������������
1237     memmove(&str[select], &str[select + 1], len - select - 1);
1238     str[len - 1] = '\0';
1239    
1240     } else if (wParam == 0x4b) { // �J�[�\�������s��������������
1241     str[select] = '\0';
1242    
1243     }
1244     }
1245    
1246     if (wParam == 0x55) { // �J�[�\����������������������
1247     if (select >= len) {
1248     str[0] = '\0';
1249     } else {
1250     str = &str[select];
1251     }
1252     select = 0;
1253     }
1254    
1255     SetWindowText(dlg, str);
1256     SendMessage(dlg, EM_SETSEL, select, select);
1257     free(orgstr);
1258     return 0;
1259     }
1260     break;
1261     }
1262     }
1263     break;
1264    
1265     // �����L�[��������������������������������������������
1266     case WM_CHAR:
1267     switch (wParam) {
1268     case 0x01:
1269     case 0x02:
1270     case 0x04:
1271     case 0x05:
1272     case 0x06:
1273     case 0x0b:
1274     case 0x0e:
1275     case 0x10:
1276     case 0x15:
1277     return 0;
1278     }
1279     }
1280    
1281     return CallWindowProc(OrigHostnameEditProc, dlg, msg, wParam, lParam);
1282     }
1283    
1284     static BOOL CALLBACK TTXHostDlg(HWND dlg, UINT msg, WPARAM wParam,
1285     LPARAM lParam)
1286     {
1287     static char *ssh_version[] = {"SSH1", "SSH2", NULL};
1288     PGetHNRec GetHNRec;
1289     char EntName[128];
1290     char TempHost[HostNameMaxLength + 1];
1291     WORD i, j, w;
1292     WORD ComPortTable[MAXCOMPORT];
1293     static char *ComPortDesc[MAXCOMPORT];
1294     int comports;
1295     BOOL Ok;
1296     LOGFONT logfont;
1297     HFONT font;
1298     char uimsg[MAX_UIMSG];
1299     static HWND hwndHostname = NULL; // HOSTNAME dropdown
1300     static HWND hwndHostnameEdit = NULL; // Edit control on HOSTNAME dropdown
1301    
1302     switch (msg) {
1303     case WM_INITDIALOG:
1304     GetHNRec = (PGetHNRec) lParam;
1305     SetWindowLong(dlg, DWL_USER, lParam);
1306    
1307     GetWindowText(dlg, uimsg, sizeof(uimsg));
1308     UTIL_get_lang_msg("DLG_HOST_TITLE", pvar, uimsg);
1309     SetWindowText(dlg, pvar->ts->UIMsg);
1310     GetDlgItemText(dlg, IDC_HOSTNAMELABEL, uimsg, sizeof(uimsg));
1311     UTIL_get_lang_msg("DLG_HOST_TCPIPHOST", pvar, uimsg);
1312     SetDlgItemText(dlg, IDC_HOSTNAMELABEL, pvar->ts->UIMsg);
1313     GetDlgItemText(dlg, IDC_HISTORY, uimsg, sizeof(uimsg));
1314     UTIL_get_lang_msg("DLG_HOST_TCPIPHISTORY", pvar, uimsg);
1315     SetDlgItemText(dlg, IDC_HISTORY, pvar->ts->UIMsg);
1316     GetDlgItemText(dlg, IDC_SERVICELABEL, uimsg, sizeof(uimsg));
1317     UTIL_get_lang_msg("DLG_HOST_TCPIPSERVICE", pvar, uimsg);
1318     SetDlgItemText(dlg, IDC_SERVICELABEL, pvar->ts->UIMsg);
1319     GetDlgItemText(dlg, IDC_HOSTOTHER, uimsg, sizeof(uimsg));
1320     UTIL_get_lang_msg("DLG_HOST_TCPIPOTHER", pvar, uimsg);
1321     SetDlgItemText(dlg, IDC_HOSTOTHER, pvar->ts->UIMsg);
1322     GetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, uimsg, sizeof(uimsg));
1323     UTIL_get_lang_msg("DLG_HOST_TCPIPPORT", pvar, uimsg);
1324     SetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, pvar->ts->UIMsg);
1325     GetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, uimsg, sizeof(uimsg));
1326     UTIL_get_lang_msg("DLG_HOST_TCPIPSSHVERSION", pvar, uimsg);
1327     SetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, pvar->ts->UIMsg);
1328     GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, uimsg, sizeof(uimsg));
1329     UTIL_get_lang_msg("DLG_HOST_TCPIPPROTOCOL", pvar, uimsg);
1330     SetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, pvar->ts->UIMsg);
1331     GetDlgItemText(dlg, IDC_HOSTSERIAL, uimsg, sizeof(uimsg));
1332     UTIL_get_lang_msg("DLG_HOST_SERIAL", pvar, uimsg);
1333     SetDlgItemText(dlg, IDC_HOSTSERIAL, pvar->ts->UIMsg);
1334     GetDlgItemText(dlg, IDC_HOSTCOMLABEL, uimsg, sizeof(uimsg));
1335     UTIL_get_lang_msg("DLG_HOST_SERIALPORT", pvar, uimsg);
1336     SetDlgItemText(dlg, IDC_HOSTCOMLABEL, pvar->ts->UIMsg);
1337     GetDlgItemText(dlg, IDC_HOSTHELP, uimsg, sizeof(uimsg));
1338     UTIL_get_lang_msg("DLG_HOST_HELP", pvar, uimsg);
1339     SetDlgItemText(dlg, IDC_HOSTHELP, pvar->ts->UIMsg);
1340     GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1341     UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1342     SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1343     GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
1344     UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
1345     SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1346    
1347     // �z�X�g�q�X�g�����`�F�b�N�{�b�N�X������ (2005.10.21 yutaka)
1348     if (pvar->ts->HistoryList > 0) {
1349     SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_CHECKED, 0);
1350     } else {
1351     SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_UNCHECKED, 0);
1352     }
1353    
1354 yutakapon 4860 // �t�@�C�����������O�t���p�C�v�������ATCP/IP�����������B
1355     if (GetHNRec->PortType == IdFile ||
1356     GetHNRec->PortType == IdNamedPipe
1357     )
1358 maya 3227 GetHNRec->PortType = IdTCPIP;
1359    
1360     strncpy_s(EntName, sizeof(EntName), "Host", _TRUNCATE);
1361    
1362     i = 1;
1363     do {
1364     _snprintf_s(&EntName[4], sizeof(EntName)-4, _TRUNCATE, "%d", i);
1365     GetPrivateProfileString("Hosts", EntName, "",
1366     TempHost, sizeof(TempHost),
1367     GetHNRec->SetupFN);
1368     if (strlen(TempHost) > 0)
1369     SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_ADDSTRING,
1370     0, (LPARAM) TempHost);
1371     i++;
1372 maya 4963 } while (i <= MAXHOSTLIST);
1373 maya 3227
1374     SendDlgItemMessage(dlg, IDC_HOSTNAME, EM_LIMITTEXT,
1375     HostNameMaxLength - 1, 0);
1376    
1377     SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_SETCURSEL, 0, 0);
1378    
1379     // C-n/C-p ���������T�u�N���X�� (2007.9.4 maya)
1380     hwndHostname = GetDlgItem(dlg, IDC_HOSTNAME);
1381     hwndHostnameEdit = GetWindow(hwndHostname, GW_CHILD);
1382     OrigHostnameEditProc = (WNDPROC)GetWindowLong(hwndHostnameEdit, GWL_WNDPROC);
1383     SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)HostnameEditProc);
1384    
1385     CheckRadioButton(dlg, IDC_HOSTTELNET, IDC_HOSTOTHER,
1386     pvar->settings.Enabled ? IDC_HOSTSSH : GetHNRec->
1387     Telnet ? IDC_HOSTTELNET : IDC_HOSTOTHER);
1388     SendDlgItemMessage(dlg, IDC_HOSTTCPPORT, EM_LIMITTEXT, 5, 0);
1389     SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TCPPort, FALSE);
1390     #ifndef NO_INET6
1391     for (i = 0; ProtocolFamilyList[i]; ++i) {
1392     SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_ADDSTRING,
1393     0, (LPARAM) ProtocolFamilyList[i]);
1394     }
1395     SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, EM_LIMITTEXT,
1396     ProtocolFamilyMaxLength - 1, 0);
1397     SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_SETCURSEL, 0, 0);
1398     #endif /* NO_INET6 */
1399    
1400     /////// SSH version
1401     for (i = 0; ssh_version[i]; ++i) {
1402     SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_ADDSTRING,
1403     0, (LPARAM) ssh_version[i]);
1404     }
1405     SendDlgItemMessage(dlg, IDC_SSH_VERSION, EM_LIMITTEXT,
1406     NUM_ELEM(ssh_version) - 1, 0);
1407    
1408     if (pvar->settings.ssh_protocol_version == 1) {
1409     SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 0, 0); // SSH1
1410     } else {
1411     SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 1, 0); // SSH2
1412     }
1413    
1414     if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1415     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE); // enabled
1416     } else {
1417     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1418     }
1419     /////// SSH version
1420    
1421    
1422     j = 0;
1423     w = 1;
1424     if ((comports=DetectComPorts(ComPortTable, GetHNRec->MaxComPort, ComPortDesc)) >= 0) {
1425     for (i=0; i<comports; i++) {
1426     // MaxComPort ���z�����|�[�g���\��������
1427     if (ComPortTable[i] > GetHNRec->MaxComPort) {
1428     continue;
1429     }
1430    
1431     // �g�p�����|�[�g���\��������
1432     if (CheckCOMFlag(ComPortTable[i]) == 1) {
1433     continue;
1434     }
1435    
1436     _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", ComPortTable[i]);
1437     if (ComPortDesc[i] != NULL) {
1438     strncat_s(EntName, sizeof(EntName), ": ", _TRUNCATE);
1439     strncat_s(EntName, sizeof(EntName), ComPortDesc[i], _TRUNCATE);
1440     }
1441     SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
1442     0, (LPARAM)EntName);
1443     j++;
1444     if (GetHNRec->ComPort == ComPortTable[i])
1445     w = j;
1446     }
1447    
1448     } else {
1449     for (i = 1; i <= GetHNRec->MaxComPort; i++) {
1450     // �g�p�����|�[�g���\��������
1451     if (CheckCOMFlag(i) == 1) {
1452     continue;
1453     }
1454    
1455     _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", i);
1456     SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
1457     0, (LPARAM) EntName);
1458     j++;
1459     if (GetHNRec->ComPort == i)
1460     w = j;
1461     }
1462     }
1463    
1464     if (j > 0)
1465     SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_SETCURSEL, w - 1, 0);
1466     else { /* All com ports are already used */
1467     GetHNRec->PortType = IdTCPIP;
1468     enable_dlg_items(dlg, IDC_HOSTSERIAL, IDC_HOSTSERIAL, FALSE);
1469     }
1470    
1471     CheckRadioButton(dlg, IDC_HOSTTCPIP, IDC_HOSTSERIAL,
1472     IDC_HOSTTCPIP + GetHNRec->PortType - 1);
1473    
1474     if (GetHNRec->PortType == IdTCPIP) {
1475     enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);
1476    
1477     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
1478     enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE);
1479    
1480     enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, TRUE); // enabled
1481     }
1482     #ifndef NO_INET6
1483     else {
1484     enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1485     FALSE);
1486     enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1487     IDC_HOSTTCPPROTOCOL, FALSE);
1488    
1489     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1490     enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)
1491    
1492     enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, FALSE); // disabled
1493     }
1494     #else
1495     else
1496     enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1497     FALSE);
1498     #endif /* NO_INET6 */
1499    
1500     // Host dialog���t�H�[�J�X�������� (2004.10.2 yutaka)
1501     if (GetHNRec->PortType == IdTCPIP) {
1502     HWND hwnd = GetDlgItem(dlg, IDC_HOSTNAME);
1503     SetFocus(hwnd);
1504     } else {
1505     HWND hwnd = GetDlgItem(dlg, IDC_HOSTCOM);
1506     SetFocus(hwnd);
1507     }
1508    
1509     font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1510     GetObject(font, sizeof(LOGFONT), &logfont);
1511     if (UTIL_get_lang_font("DLG_SYSTEM_FONT", dlg, &logfont, &DlgHostFont, pvar)) {
1512     SendDlgItemMessage(dlg, IDC_HOSTTCPIP, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1513     SendDlgItemMessage(dlg, IDC_HOSTNAMELABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1514     SendDlgItemMessage(dlg, IDC_HOSTNAME, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1515     SendDlgItemMessage(dlg, IDC_HISTORY, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1516     SendDlgItemMessage(dlg, IDC_SERVICELABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1517     SendDlgItemMessage(dlg, IDC_HOSTTELNET, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1518     SendDlgItemMessage(dlg, IDC_HOSTSSH, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1519     SendDlgItemMessage(dlg, IDC_HOSTOTHER, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1520     SendDlgItemMessage(dlg, IDC_HOSTTCPPORTLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1521     SendDlgItemMessage(dlg, IDC_HOSTTCPPORT, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1522     SendDlgItemMessage(dlg, IDC_SSH_VERSION_LABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1523     SendDlgItemMessage(dlg, IDC_SSH_VERSION, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1524     SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOLLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1525     SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1526     SendDlgItemMessage(dlg, IDC_HOSTSERIAL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1527     SendDlgItemMessage(dlg, IDC_HOSTCOMLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1528     SendDlgItemMessage(dlg, IDC_HOSTCOM, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1529     SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1530     SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1531     SendDlgItemMessage(dlg, IDC_HOSTHELP, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1532     }
1533     else {
1534     DlgHostFont = NULL;
1535     }
1536    
1537     // SetFocus()���t�H�[�J�X���������������AFALSE�������K�v�������B
1538     // TRUE���������ATABSTOP�������������������R���g���[�����I�������B
1539     // (2004.11.23 yutaka)
1540     return FALSE;
1541     //return TRUE;
1542    
1543     case WM_COMMAND:
1544     switch (LOWORD(wParam)) {
1545     case IDOK:
1546     GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);
1547     if (GetHNRec != NULL) {
1548     if (IsDlgButtonChecked(dlg, IDC_HOSTTCPIP)) {
1549     #ifndef NO_INET6
1550     char afstr[BUFSIZ];
1551     #endif /* NO_INET6 */
1552     i = GetDlgItemInt(dlg, IDC_HOSTTCPPORT, &Ok, FALSE);
1553     if (Ok) {
1554     GetHNRec->TCPPort = i;
1555     } else {
1556     UTIL_get_lang_msg("MSG_TCPPORT_NAN_ERROR", pvar,
1557     "The TCP port must be a number.");
1558     MessageBox(dlg, pvar->ts->UIMsg,
1559     "Tera Term", MB_OK | MB_ICONEXCLAMATION);
1560     return TRUE;
1561     }
1562     #ifndef NO_INET6
1563     #define getaf(str) \
1564     ((strcmp((str), "IPv6") == 0) ? AF_INET6 : \
1565     ((strcmp((str), "IPv4") == 0) ? AF_INET : AF_UNSPEC))
1566     memset(afstr, 0, sizeof(afstr));
1567     GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOL, afstr,
1568     sizeof(afstr));
1569     GetHNRec->ProtocolFamily = getaf(afstr);
1570     #endif /* NO_INET6 */
1571     GetHNRec->PortType = IdTCPIP;
1572     GetDlgItemText(dlg, IDC_HOSTNAME, GetHNRec->HostName,
1573     HostNameMaxLength);
1574     pvar->hostdlg_activated = TRUE;
1575     pvar->hostdlg_Enabled = FALSE;
1576     if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
1577     GetHNRec->Telnet = TRUE;
1578     } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1579     pvar->hostdlg_Enabled = TRUE;
1580    
1581     // check SSH protocol version
1582     memset(afstr, 0, sizeof(afstr));
1583     GetDlgItemText(dlg, IDC_SSH_VERSION, afstr, sizeof(afstr));
1584     if (_stricmp(afstr, "SSH1") == 0) {
1585     pvar->settings.ssh_protocol_version = 1;
1586     } else {
1587     pvar->settings.ssh_protocol_version = 2;
1588     }
1589     }
1590 doda 3541 else { // IDC_HOSTOTHER
1591     GetHNRec->Telnet = FALSE;
1592     }
1593 maya 3227
1594     // host history check button
1595     if (SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_GETCHECK, 0, 0) == BST_CHECKED) {
1596     pvar->ts->HistoryList = 1;
1597     } else {
1598     pvar->ts->HistoryList = 0;
1599     }
1600    
1601     } else {
1602     GetHNRec->PortType = IdSerial;
1603     GetHNRec->HostName[0] = 0;
1604     memset(EntName, 0, sizeof(EntName));
1605     GetDlgItemText(dlg, IDC_HOSTCOM, EntName,
1606     sizeof(EntName) - 1);
1607     if (strncmp(EntName, "COM", 3) == 0 && EntName[3] != '\0') {
1608     #if 0
1609     GetHNRec->ComPort = (BYTE) (EntName[3]) - 0x30;
1610     if (strlen(EntName) > 4)
1611     GetHNRec->ComPort =
1612     GetHNRec->ComPort * 10 + (BYTE) (EntName[4]) -
1613     0x30;
1614     #else
1615     GetHNRec->ComPort = atoi(&EntName[3]);
1616     #endif
1617     if (GetHNRec->ComPort > GetHNRec->MaxComPort)
1618     GetHNRec->ComPort = 1;
1619     } else {
1620     GetHNRec->ComPort = 1;
1621     }
1622     }
1623     }
1624     SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
1625     EndDialog(dlg, 1);
1626    
1627     if (DlgHostFont != NULL) {
1628     DeleteObject(DlgHostFont);
1629     }
1630    
1631     return TRUE;
1632    
1633     case IDCANCEL:
1634     SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
1635     EndDialog(dlg, 0);
1636    
1637     if (DlgHostFont != NULL) {
1638     DeleteObject(DlgHostFont);
1639     }
1640    
1641     return TRUE;
1642    
1643     case IDC_HOSTTCPIP:
1644     enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1645     TRUE);
1646     #ifndef NO_INET6
1647     enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1648     IDC_HOSTTCPPROTOCOL, TRUE);
1649     #endif /* NO_INET6 */
1650     enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);
1651    
1652     enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE); // disabled (2004.11.23 yutaka)
1653     if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1654     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
1655     } else {
1656     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1657     }
1658    
1659     enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, TRUE); // disabled
1660    
1661     return TRUE;
1662    
1663     case IDC_HOSTSERIAL:
1664     enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, TRUE);
1665     enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1666     FALSE);
1667     #ifndef NO_INET6
1668     enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1669     IDC_HOSTTCPPROTOCOL, FALSE);
1670     #endif /* NO_INET6 */
1671     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1672     enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)
1673    
1674     enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, FALSE); // disabled
1675    
1676     return TRUE;
1677    
1678     case IDC_HOSTSSH:
1679     enable_dlg_items(dlg, IDC_SSH_VERSION,
1680     IDC_SSH_VERSION, TRUE);
1681     goto hostssh_enabled;
1682    
1683     case IDC_HOSTTELNET:
1684     case IDC_HOSTOTHER:
1685     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1686     hostssh_enabled:
1687    
1688     GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);
1689    
1690     if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
1691     if (GetHNRec != NULL)
1692     SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TelPort,
1693     FALSE);
1694     } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1695     SetDlgItemInt(dlg, IDC_HOSTTCPPORT, 22, FALSE);
1696     }
1697     return TRUE;
1698    
1699     case IDC_HOSTCOM:
1700     if(HIWORD(wParam) == CBN_DROPDOWN) {
1701     HWND hostcom = GetDlgItem(dlg, IDC_HOSTCOM);
1702     int count = SendMessage(hostcom, CB_GETCOUNT, 0, 0);
1703     int i, len, max_len = 0;
1704     char *lbl;
1705     HDC TmpDC = GetDC(hostcom);
1706     SIZE s;
1707     for (i=0; i<count; i++) {
1708     len = SendMessage(hostcom, CB_GETLBTEXTLEN, i, 0);
1709     lbl = (char *)calloc(len+1, sizeof(char));
1710     SendMessage(hostcom, CB_GETLBTEXT, i, (LPARAM)lbl);
1711     GetTextExtentPoint32(TmpDC, lbl, len, &s);
1712     if (s.cx > max_len)
1713     max_len = s.cx;
1714     free(lbl);
1715     }
1716     SendMessage(hostcom, CB_SETDROPPEDWIDTH,
1717     max_len + GetSystemMetrics(SM_CXVSCROLL), 0);
1718     }
1719     break;
1720    
1721     case IDC_HOSTHELP:
1722     PostMessage(GetParent(dlg), WM_USER_DLGHELP2, 0, 0);
1723     }
1724     }
1725     return FALSE;
1726     }
1727    
1728     static BOOL FAR PASCAL TTXGetHostName(HWND parent, PGetHNRec rec)
1729     {
1730     return (BOOL) DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_HOSTDLG),
1731     parent, TTXHostDlg, (LONG) rec);
1732     }
1733    
1734     static void PASCAL FAR TTXGetUIHooks(TTXUIHooks FAR * hooks)
1735     {
1736     *hooks->GetHostName = TTXGetHostName;
1737     }
1738    
1739     static void FAR PASCAL TTXReadINIFile(PCHAR fileName, PTTSet ts)
1740     {
1741     (pvar->ReadIniFile) (fileName, ts);
1742     read_ssh_options(pvar, fileName);
1743     pvar->settings = *pvar->ts_SSH;
1744     notify_verbose_message(pvar, "Reading INI file", LOG_LEVEL_VERBOSE);
1745     FWDUI_load_settings(pvar);
1746     }
1747    
1748     static void FAR PASCAL TTXWriteINIFile(PCHAR fileName, PTTSet ts)
1749     {
1750     (pvar->WriteIniFile) (fileName, ts);
1751     *pvar->ts_SSH = pvar->settings;
1752     clear_local_settings(pvar);
1753     notify_verbose_message(pvar, "Writing INI file", LOG_LEVEL_VERBOSE);
1754     write_ssh_options(pvar, fileName, pvar->ts_SSH, TRUE);
1755     }
1756    
1757     static void read_ssh_options_from_user_file(PTInstVar pvar,
1758     char FAR * user_file_name)
1759     {
1760     if (user_file_name[0] == '.') {
1761     read_ssh_options(pvar, user_file_name);
1762     } else {
1763     char buf[1024];
1764    
1765     get_teraterm_dir_relative_name(buf, sizeof(buf), user_file_name);
1766     read_ssh_options(pvar, buf);
1767     }
1768    
1769     pvar->settings = *pvar->ts_SSH;
1770     FWDUI_load_settings(pvar);
1771     }
1772    
1773     // Percent-encode������������src���f�R�[�h����dst���R�s�[�����B
1774     // dstlen��dst���T�C�Y�B�����������������������A�����������������������B
1775     static void percent_decode(char *dst, int dstlen, char *src) {
1776     if (src == NULL || dst == NULL || dstlen < 1) {
1777     return;
1778     }
1779    
1780     while (*src != 0 && dstlen > 1) {
1781     if (*src == '%' && isxdigit(*(src+1)) && isxdigit(*(src+2))) {
1782     src++; *dst = (isalpha(*src) ? (*src|0x20) - 'a' + 10 : *src - '0') << 4;
1783     src++; *dst |= (isalpha(*src) ? (*src|0x20) - 'a' + 10 : *src - '0');
1784     src++; dst++;
1785     }
1786     else {
1787     *dst++ = *src++;
1788     }
1789     dstlen--;
1790     }
1791     *dst = 0;
1792     return;
1793     }
1794    
1795 doda 5799 void add_forward_param(PTInstVar pvar, char *param)
1796     {
1797     if (pvar->settings.DefaultForwarding[0] == 0) {
1798     strncpy_s(pvar->settings.DefaultForwarding,
1799     sizeof(pvar->settings.DefaultForwarding),
1800     param, _TRUNCATE);
1801     } else {
1802     strncat_s(pvar->settings.DefaultForwarding,
1803     sizeof(pvar->settings.DefaultForwarding),
1804     ";", _TRUNCATE);
1805     strncat_s(pvar->settings.DefaultForwarding,
1806     sizeof(pvar->settings.DefaultForwarding),
1807     param, _TRUNCATE);
1808     }
1809     }
1810    
1811 maya 5869 static void FAR PASCAL TTXParseParam(PCHAR param, PTTSet ts, PCHAR DDETopic) {
1812     int param_len=strlen(param);
1813     int opt_len = param_len+1;
1814     char *option = (char *)calloc(opt_len, sizeof(char));
1815 maya 5882 char *option2 = (char *)calloc(opt_len, sizeof(char));
1816 maya 5869 int action;
1817 maya 5874 PCHAR start, cur, next;
1818 maya 5908 size_t i;
1819 maya 5869
1820     if (pvar->hostdlg_activated) {
1821     pvar->settings.Enabled = pvar->hostdlg_Enabled;
1822     }
1823    
1824 maya 5874 /* the first term shuld be executable filename of Tera Term */
1825     start = GetParam(option, opt_len, param);
1826    
1827     cur = start;
1828 maya 5869 while (next = GetParam(option, opt_len, cur)) {
1829 doda 6140 DequoteParam(option, opt_len, option);
1830 maya 5869 action = OPTION_NONE;
1831    
1832     if ((option[0] == '-' || option[0] == '/')) {
1833     if (MATCH_STR(option + 1, "ssh") == 0) {
1834     if (MATCH_STR(option + 4, "-f=") == 0) {
1835 doda 6140 strncpy_s(option2, opt_len, option + 7, _TRUNCATE);
1836 maya 5882 read_ssh_options_from_user_file(pvar, option2);
1837 maya 5869 action = OPTION_CLEAR;
1838     } else if (MATCH_STR(option + 4, "-consume=") == 0) {
1839 doda 6140 strncpy_s(option2, opt_len, option + 13, _TRUNCATE);
1840 maya 5882 read_ssh_options_from_user_file(pvar, option2);
1841     DeleteFile(option2);
1842 maya 5869 action = OPTION_CLEAR;
1843     }
1844    
1845     // ttermpro.exe �� /F= �w������ TTSSH ������������ (2006.10.11 maya)
1846     } else if (MATCH_STR_I(option + 1, "f=") == 0) {
1847 doda 6140 strncpy_s(option2, opt_len, option + 3, _TRUNCATE);
1848 maya 5882 read_ssh_options_from_user_file(pvar, option2);
1849 maya 5869 // Tera Term���������������K�v������������������
1850     }
1851     }
1852    
1853     switch (action) {
1854     case OPTION_CLEAR:
1855     memset(cur, ' ', next-cur);
1856     break;
1857     case OPTION_REPLACE:
1858     memset(cur, ' ', next-cur);
1859     memcpy(cur+1, option, strlen(option));
1860     break;
1861     }
1862    
1863     cur = next;
1864     }
1865    
1866 maya 5874 cur = start;
1867 maya 5869 while (next = GetParam(option, opt_len, cur)) {
1868 doda 6140 DequoteParam(option, opt_len, option);
1869 maya 5869 action = OPTION_NONE;
1870    
1871     if ((option[0] == '-' || option[0] == '/')) {
1872     action = OPTION_CLEAR;
1873     if (MATCH_STR(option + 1, "ssh") == 0) {
1874     if (option[4] == 0) {
1875     pvar->settings.Enabled = 1;
1876     } else if (MATCH_STR(option + 4, "-L") == 0 ||
1877 doda 5959 MATCH_STR(option + 4, "-R") == 0) {
1878     char *p = option + 5;
1879     option2[0] = *p;
1880     i = 1;
1881     while (*++p) {
1882     if (*p == ';' || *p == ',') {
1883     option2[i] = 0;
1884     add_forward_param(pvar, option2);
1885     i = 1;
1886 maya 5908 }
1887 doda 5959 else {
1888     option2[i++] = *p;
1889     }
1890 maya 5908 }
1891 doda 5959 if (i > 1) {
1892     option2[i] = 0;
1893     add_forward_param(pvar, option2);
1894     }
1895 maya 5869 } else if (MATCH_STR(option + 4, "-X") == 0) {
1896     add_forward_param(pvar, "X");
1897 doda 5959 if (option+6 != 0) {
1898     strncpy_s(pvar->settings.X11Display,
1899     sizeof(pvar->settings.X11Display),
1900     option + 6, _TRUNCATE);
1901     }
1902 doda 6473 } else if (strcmp(option + 4, "-v") == 0) {
1903 maya 5869 pvar->settings.LogLevel = LOG_LEVEL_VERBOSE;
1904     } else if (_stricmp(option + 4, "-autologin") == 0 ||
1905     _stricmp(option + 4, "-autologon") == 0) {
1906     pvar->settings.TryDefaultAuth = TRUE;
1907     } else if (MATCH_STR_I(option + 4, "-agentconfirm=") == 0) {
1908     if ((_stricmp(option+18, "off") == 0) ||
1909     (_stricmp(option+18, "no") == 0) ||
1910     (_stricmp(option+18, "false") == 0) ||
1911     (_stricmp(option+18, "0") == 0) ||
1912     (_stricmp(option+18, "n") == 0)) {
1913     pvar->settings.ForwardAgentConfirm = 0;
1914     }
1915     else {
1916     pvar->settings.ForwardAgentConfirm = 1;
1917     }
1918 doda 6473 } else if (strcmp(option + 4, "-a") == 0) {
1919 maya 5869 pvar->settings.ForwardAgent = FALSE;
1920 doda 6473 } else if (strcmp(option + 4, "-A") == 0) {
1921 maya 5869 pvar->settings.ForwardAgent = TRUE;
1922    
1923     } else if (MATCH_STR(option + 4, "-C=") == 0) {
1924     pvar->settings.CompressionLevel = atoi(option+7);
1925     if (pvar->settings.CompressionLevel < 0) {
1926     pvar->settings.CompressionLevel = 0;
1927     }
1928     else if (pvar->settings.CompressionLevel > 9) {
1929     pvar->settings.CompressionLevel = 9;
1930     }
1931 doda 6473 } else if (strcmp(option + 4, "-C") == 0) {
1932 maya 5869 pvar->settings.CompressionLevel = 6;
1933 doda 6473 } else if (strcmp(option + 4, "-c") == 0) {
1934 maya 5869 pvar->settings.CompressionLevel = 0;
1935     } else if (MATCH_STR_I(option + 4, "-icon=") == 0) {
1936     if ((_stricmp(option+10, "old") == 0) ||
1937     (_stricmp(option+10, "yellow") == 0) ||
1938     (_stricmp(option+10, "securett_yellow") == 0)) {
1939     pvar->settings.IconID = IDI_SECURETT_YELLOW;
1940     }
1941 maya 6386 else if ((_stricmp(option+10, "green") == 0) ||
1942     (_stricmp(option+10, "securett_green") == 0)) {
1943     pvar->settings.IconID = IDI_SECURETT_GREEN;
1944     }
1945 maya 5869 else {
1946     pvar->settings.IconID = IDI_SECURETT;
1947     }
1948    
1949     // /ssh1 �� /ssh2 �I�v�V�������V�K���� (2006.9.16 maya)
1950 doda 6473 } else if (strcmp(option + 4, "1") == 0) {
1951 maya 5869 pvar->settings.Enabled = 1;
1952     pvar->settings.ssh_protocol_version = 1;
1953 doda 6473 } else if (strcmp(option + 4, "2") == 0) {
1954 maya 5869 pvar->settings.Enabled = 1;
1955     pvar->settings.ssh_protocol_version = 2;
1956    
1957     } else {
1958     char buf[1024];
1959    
1960     UTIL_get_lang_msg("MSG_UNKNOWN_OPTION_ERROR", pvar,
1961     "Unrecognized command-line option: %s");
1962     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg, option);
1963    
1964     MessageBox(NULL, buf, "TTSSH", MB_OK | MB_ICONEXCLAMATION);
1965     }
1966    
1967     // ttermpro.exe �� /T= �w�������p�������A������������ (2006.10.19 maya)
1968     } else if (MATCH_STR_I(option + 1, "t=") == 0) {
1969     if (strcmp(option + 3, "2") == 0) {
1970     pvar->settings.Enabled = 1;
1971     // /t=2��ttssh�������g������������
1972     } else {
1973     pvar->settings.Enabled = 0;
1974     action = OPTION_NONE; // Tera Term������������������������
1975     }
1976    
1977     // /1 ������ /2 �I�v�V�������V�K���� (2004.10.3 yutaka)
1978 doda 6473 } else if (strcmp(option + 1, "1") == 0) {
1979 maya 5869 // command line: /ssh /1 is SSH1 only
1980     pvar->settings.ssh_protocol_version = 1;
1981    
1982 doda 6473 } else if (strcmp(option + 1, "2") == 0) {
1983 maya 5869 // command line: /ssh /2 is SSH2 & SSH1
1984     pvar->settings.ssh_protocol_version = 2;
1985    
1986 doda 6473 } else if (strcmp(option + 1, "nossh") == 0) {
1987 maya 5869 // '/nossh' �I�v�V�����������B
1988     // TERATERM.INI ��SSH���L�������������������A������Cygterm���N��������������
1989     // �����������������B(2004.10.11 yutaka)
1990     pvar->settings.Enabled = 0;
1991    
1992 doda 6473 } else if (strcmp(option + 1, "telnet") == 0) {
1993 maya 5869 // '/telnet' ���w�������������������� '/nossh' ��������
1994     // SSH������������ (2006.9.16 maya)
1995     pvar->settings.Enabled = 0;
1996     // Tera Term �� Telnet �t���O���t����
1997     pvar->ts->Telnet = 1;
1998    
1999 doda 6473 } else if (MATCH_STR(option + 1, "auth=") == 0) {
2000 maya 5869 // SSH2�������O�C���I�v�V����������
2001     //
2002     // SYNOPSIS: /ssh /auth=passowrd /user=���[�U�� /passwd=�p�X���[�h
2003     // /ssh /auth=publickey /user=���[�U�� /passwd=�p�X���[�h /keyfile=�p�X
2004 doda 6472 // EXAMPLE: /ssh /auth=password /user=nike /passwd="a b""c" ; �p�X���[�h: �ua b"c�v
2005 maya 5869 // /ssh /auth=publickey /user=foo /passwd=bar /keyfile=d:\tmp\id_rsa
2006 doda 6472 // NOTICE: �p�X���[�h���p�X���������Z�~�R���������������������_�u���N�H�[�g " ������
2007     // �p�X���[�h���_�u���N�H�[�g�����������������A�������_�u���N�H�[�g "" ���u��������
2008 maya 5869 //
2009     pvar->ssh2_autologin = 1; // for SSH2 (2004.11.30 yutaka)
2010    
2011 doda 6473 if (_stricmp(option + 6, "password") == 0) { // �p�X���[�h
2012 maya 5869 //pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
2013     pvar->ssh2_authmethod = SSH_AUTH_PASSWORD;
2014    
2015     // /auth=challenge ������ (2007.10.5 maya)
2016 doda 6473 } else if (_stricmp(option + 6, "challenge") == 0) { // keyboard-interactive�F��
2017 maya 5869 //pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
2018     pvar->ssh2_authmethod = SSH_AUTH_TIS;
2019    
2020 doda 6473 } else if (_stricmp(option + 6, "publickey") == 0) { // ���J���F��
2021 maya 5869 //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
2022     pvar->ssh2_authmethod = SSH_AUTH_RSA;
2023    
2024 doda 6473 } else if (_stricmp(option + 6, "pageant") == 0) { // ���J���F�� by Pageant
2025 maya 5869 //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
2026     pvar->ssh2_authmethod = SSH_AUTH_PAGEANT;
2027    
2028     } else {
2029     // TODO:
2030     }
2031    
2032     } else if (MATCH_STR(option + 1, "user=") == 0) {
2033 doda 6140 _snprintf_s(pvar->ssh2_username, sizeof(pvar->ssh2_username), _TRUNCATE, "%s", option+6);
2034 maya 5869
2035     } else if (MATCH_STR(option + 1, "passwd=") == 0) {
2036 doda 6140 _snprintf_s(pvar->ssh2_password, sizeof(pvar->ssh2_password), _TRUNCATE, "%s", option+8);
2037 maya 5869
2038     } else if (MATCH_STR(option + 1, "keyfile=") == 0) {
2039 doda 6140 _snprintf_s(pvar->ssh2_keyfile, sizeof(pvar->ssh2_keyfile), _TRUNCATE, "%s", option+9);
2040 maya 5869
2041 doda 6473 } else if (strcmp(option + 1, "ask4passwd") == 0) {
2042 maya 5869 // �p�X���[�h������ (2006.9.18 maya)
2043     pvar->ask4passwd = 1;
2044    
2045 doda 6473 } else if (strcmp(option + 1, "nosecuritywarning") == 0) {
2046 maya 5869 // known_hosts�`�F�b�N���������B���Y�I�v�V�������g�����A�Z�L�����e�B������������
2047     // �����A�B���I�v�V���������������B
2048     // (2009.10.4 yutaka)
2049     pvar->nocheck_known_hosts = TRUE;
2050    
2051     }
2052     else { // Other (not ttssh) option
2053     action = OPTION_NONE; // ttssh���I�v�V������������������������
2054     }
2055    
2056     // �p�X���[�h�������������������O�C��������������
2057     // /auth ���F�����\�b�h���w�������������p������ (2006.9.18 maya)
2058     if (pvar->ask4passwd == 1) {
2059     pvar->ssh2_autologin = 0;
2060     }
2061    
2062     }
2063     else if ((MATCH_STR_I(option, "ssh://") == 0) ||
2064     (MATCH_STR_I(option, "ssh1://") == 0) ||
2065     (MATCH_STR_I(option, "ssh2://") == 0) ||
2066     (MATCH_STR_I(option, "slogin://") == 0) ||
2067     (MATCH_STR_I(option, "slogin1://") == 0) ||
2068     (MATCH_STR_I(option, "slogin2://") == 0)) {
2069     //
2070     // ssh://user@host/ ����URL�`�����T�|�[�g
2071     // ���{�I�������� telnet:// URL��������
2072     //
2073     // �Q�l:
2074     // RFC3986: Uniform Resource Identifier (URI): Generic Syntax
2075     // RFC4248: The telnet URI Scheme
2076     //
2077     char *p, *p2, *p3;
2078     int optlen, hostlen;
2079    
2080     optlen = strlen(option);
2081    
2082     // ������':'���O�����������������������A������ssh�v���g�R���o�[�W������������
2083     p = _mbschr(option, ':');
2084     switch (*(p-1)) {
2085     case '1':
2086     pvar->settings.ssh_protocol_version = 1;
2087     break;
2088     case '2':
2089     pvar->settings.ssh_protocol_version = 2;
2090     break;
2091     }
2092    
2093     // authority part �����|�C���^������
2094     p += 3;
2095    
2096     // path part ������������
2097     if ((p2 = _mbschr(p, '/')) != NULL) {
2098     *p2 = 0;
2099     }
2100    
2101     // '@'�������������A���������O�����[�U����
2102     if ((p2 = _mbschr(p, '@')) != NULL) {
2103     *p2 = 0;
2104     // ':'���~���p�X���[�h
2105     if ((p3 = _mbschr(p, ':')) != NULL) {
2106     *p3 = 0;
2107     percent_decode(pvar->ssh2_password, sizeof(pvar->ssh2_password), p3 + 1);
2108     }
2109     percent_decode(pvar->ssh2_username, sizeof(pvar->ssh2_username), p);
2110     // p �� host part ������('@'����������)����������������
2111     p = p2 + 1;
2112     }
2113    
2114     // host part �� option �����������������Ascheme part ������
2115     // port�w����������������port���������������������m��������������
2116     hostlen = strlen(p);
2117     memmove_s(option, optlen, p, hostlen);
2118     option[hostlen] = 0;
2119    
2120     // �|�[�g�w������������":22"������
2121     #ifndef NO_INET6
2122     if (option[0] == '[' && option[hostlen-1] == ']' || // IPv6 raw address without port
2123     option[0] != '[' && _mbschr(option, ':') == NULL) { // hostname or IPv4 raw address without port
2124     #else
2125     if (_mbschr(option, ':') == NULL) {
2126     #endif /* NO_INET6 */
2127     memcpy_s(option+hostlen, optlen-hostlen, ":22", 3);
2128     hostlen += 3;
2129     }
2130    
2131     // �|�[�g�w�����������������X�y�[�X������
2132     memset(option+hostlen, ' ', optlen-hostlen);
2133    
2134     pvar->settings.Enabled = 1;
2135    
2136     action = OPTION_REPLACE;
2137     }
2138     else if (_mbschr(option, '@') != NULL) {
2139     //
2140     // user@host �`�����T�|�[�g
2141     // ����������ssh�������T�|�[�g�����A���[�U����ttssh���������B
2142     // (ssh�������O -- ttssh�������W������������)
2143     // �����I��telnet authentication option���T�|�[�g��������
2144     // Tera Term�{�����������������������\���B
2145     //
2146     char *p;
2147     p = _mbschr(option, '@');
2148     *p = 0;
2149    
2150     strncpy_s(pvar->ssh2_username, sizeof(pvar->ssh2_username), option, _TRUNCATE);
2151    
2152     // ���[�U���������X�y�[�X�������B
2153     // ������TTX��Tera Term�{�������������������X�y�[�X�����������������A
2154     // �z�X�g�����������l�����K�v�������B
2155     memset(option, ' ', p-option+1);
2156    
2157     action = OPTION_REPLACE;
2158     }
2159    
2160    
2161     switch (action) {
2162     case OPTION_CLEAR:
2163     memset(cur, ' ', next-cur);
2164     break;
2165     case OPTION_REPLACE:
2166     memset(cur, ' ', next-cur);
2167     memcpy(cur+1, option, strlen(option));
2168     break;
2169     }
2170    
2171     cur = next;
2172     }
2173    
2174     free(option);
2175    
2176     FWDUI_load_settings(pvar);
2177    
2178     (pvar->ParseParam) (param, ts, DDETopic);
2179     }
2180 maya 3227
2181     static void PASCAL FAR TTXGetSetupHooks(TTXSetupHooks FAR * hooks)
2182     {
2183     pvar->ReadIniFile = *hooks->ReadIniFile;
2184     pvar->WriteIniFile = *hooks->WriteIniFile;
2185     pvar->ParseParam = *hooks->ParseParam;
2186    
2187     *hooks->ReadIniFile = TTXReadINIFile;
2188     *hooks->WriteIniFile = TTXWriteINIFile;
2189     *hooks->ParseParam = TTXParseParam;
2190     }
2191    
2192     static void PASCAL FAR TTXSetWinSize(int rows, int cols)
2193     {
2194     SSH_notify_win_size(pvar, cols, rows);
2195     }
2196    
2197     static void insertMenuBeforeItem(HMENU menu, WORD beforeItemID, WORD flags,
2198     WORD newItemID, char FAR * text)
2199     {
2200     int i, j;
2201    
2202     for (i = GetMenuItemCount(menu) - 1; i >= 0; i--) {
2203     HMENU submenu = GetSubMenu(menu, i);
2204    
2205     for (j = GetMenuItemCount(submenu) - 1; j >= 0; j--) {
2206     if (GetMenuItemID(submenu, j) == beforeItemID) {
2207     InsertMenu(submenu, j, MF_BYPOSITION | flags, newItemID, text);
2208     return;
2209     }
2210     }
2211     }
2212     }
2213    
2214 doda 4463 #define GetFileMenu(menu) GetSubMenuByChildID(menu, 50110) // ID_FILE_NEWCONNECTION
2215     #define GetEditMenu(menu) GetSubMenuByChildID(menu, 50210) // ID_EDIT_COPY2
2216     #define GetSetupMenu(menu) GetSubMenuByChildID(menu, 50310) // ID_SETUP_TERMINAL
2217     #define GetControlMenu(menu) GetSubMenuByChildID(menu, 50410) // ID_CONTROL_RESETTERMINAL
2218     #define GetHelpMenu(menu) GetSubMenuByChildID(menu, 50990) // ID_HELP_ABOUT
2219    
2220     HMENU GetSubMenuByChildID(HMENU menu, UINT id) {
2221     int i, j, items, subitems, cur_id;
2222     HMENU m;
2223    
2224     items = GetMenuItemCount(menu);
2225    
2226     for (i=0; i<items; i++) {
2227     if (m = GetSubMenu(menu, i)) {
2228     subitems = GetMenuItemCount(m);
2229     for (j=0; j<subitems; j++) {
2230     cur_id = GetMenuItemID(m, j);
2231     if (cur_id == id) {
2232     return m;
2233     }
2234     }
2235     }
2236     }
2237     return NULL;
2238     }
2239    
2240 maya 3227 static void PASCAL FAR TTXModifyMenu(HMENU menu)
2241     {
2242 doda 4463 pvar->FileMenu = GetFileMenu(menu);
2243    
2244 maya 3227 /* inserts before ID_HELP_ABOUT */
2245     UTIL_get_lang_msg("MENU_ABOUT", pvar, "About &TTSSH...");
2246     insertMenuBeforeItem(menu, 50990, MF_ENABLED, ID_ABOUTMENU, pvar->ts->UIMsg);
2247    
2248     /* inserts before ID_SETUP_TCPIP */
2249     UTIL_get_lang_msg("MENU_SSH", pvar, "SS&H...");
2250     insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHSETUPMENU, pvar->ts->UIMsg);
2251     /* inserts before ID_SETUP_TCPIP */
2252     UTIL_get_lang_msg("MENU_SSH_AUTH", pvar, "SSH &Authentication...");
2253     insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHAUTHSETUPMENU, pvar->ts->UIMsg);
2254     /* inserts before ID_SETUP_TCPIP */
2255     UTIL_get_lang_msg("MENU_SSH_FORWARD", pvar, "SSH F&orwarding...");
2256     insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHFWDSETUPMENU, pvar->ts->UIMsg);
2257     UTIL_get_lang_msg("MENU_SSH_KEYGEN", pvar, "SSH KeyGe&nerator...");
2258     insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHKEYGENMENU, pvar->ts->UIMsg);
2259    
2260     /* inserts before ID_FILE_CHANGEDIR */
2261     UTIL_get_lang_msg("MENU_SSH_SCP", pvar, "SS&H SCP...");
2262 doda 4463 insertMenuBeforeItem(menu, 50170, MF_GRAYED, ID_SSHSCPMENU, pvar->ts->UIMsg);
2263 maya 3227 }
2264    
2265 doda 4463 static void PASCAL FAR TTXModifyPopupMenu(HMENU menu) {
2266     if (menu == pvar->FileMenu) {
2267     if (pvar->cv->Ready && pvar->settings.Enabled)
2268     EnableMenuItem(menu, ID_SSHSCPMENU, MF_BYCOMMAND | MF_ENABLED);
2269     else
2270     EnableMenuItem(menu, ID_SSHSCPMENU, MF_BYCOMMAND | MF_GRAYED);
2271     }
2272     }
2273    
2274 maya 3227 // ���s�t�@�C�������o�[�W�������������� (2005.2.28 yutaka)
2275     void get_file_version(char *exefile, int *major, int *minor, int *release, int *build)
2276     {
2277     typedef struct {
2278     WORD wLanguage;
2279     WORD wCodePage;
2280     } LANGANDCODEPAGE, *LPLANGANDCODEPAGE;
2281     LPLANGANDCODEPAGE lplgcode;
2282     UINT unLen;
2283     DWORD size;
2284     char *buf = NULL;
2285     BOOL ret;
2286     int i;
2287     char fmt[80];
2288     char *pbuf;
2289    
2290     size =