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