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