Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 5359 - (show annotations) (download) (as text)
Sun Aug 18 10:02:56 2013 UTC (10 years, 7 months ago) by yutakapon
Original Path: trunk/ttssh2/ttxssh/ttxssh.c
File MIME type: text/x-csrc
File size: 168290 byte(s) 
SCPの受信先を更新した場合、teraterm.iniの FileDir エントリも併せて
更新するようにした。
チケット #31713
1 /*
2 Copyright (c) 1998-2001, Robert O'Callahan
3 All rights reserved.
4
5 Redistribution and use in source and binary forms, with or without modification,
6 are permitted provided that the following conditions are met:
7
8 Redistributions of source code must retain the above copyright notice, this list of
9 conditions and the following disclaimer.
10
11 Redistributions in binary form must reproduce the above copyright notice, this list
12 of conditions and the following disclaimer in the documentation and/or other materials
13 provided with the distribution.
14
15 The name of Robert O'Callahan may not be used to endorse or promote products derived from
16 this software without specific prior written permission.
17
18 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
19 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21 THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
25 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 /* Tera Term extension mechanism
30 Robert O'Callahan (roc+tt@cs.cmu.edu)
31
32 Tera Term by Takashi Teranishi (teranishi@rikaxp.riken.go.jp)
33 */
34
35 #include "ttxssh.h"
36 #include "fwdui.h"
37 #include "util.h"
38 #include "ssh.h"
39 #include "ttcommon.h"
40 #include "ttlib.h"
41
42 #include <stdlib.h>
43 #include <stdio.h>
44 #include <string.h>
45 #include <io.h>
46 #include <fcntl.h>
47 #include <sys/stat.h>
48 #include <time.h>
49 #include <mbstring.h>
50
51 #include "resource.h"
52 #include <commctrl.h>
53 #include <commdlg.h>
54 #ifndef NO_INET6
55 #include <winsock2.h>
56 static char FAR *ProtocolFamilyList[] = { "UNSPEC", "IPv6", "IPv4", NULL };
57 #else
58 #include <winsock.h>
59 #endif /* NO_INET6 */
60
61 #include <Lmcons.h>
62
63 // include OpenSSL header file
64 #include <openssl/opensslv.h>
65 #include <openssl/evp.h>
66 #include <openssl/rsa.h>
67 #include <openssl/dsa.h>
68 #include <openssl/bn.h>
69 #include <openssl/pem.h>
70 #include <openssl/rand.h>
71 #include <openssl/rc4.h>
72 #include <openssl/md5.h>
73
74 // include ZLib header file
75 #include <zlib.h>
76
77 #include "buffer.h"
78 #include "cipher.h"
79 #include "key.h"
80
81 #include "sftp.h"
82
83 #include "compat_w95.h"
84
85 #include "puttyversion.h"
86
87 #define MATCH_STR(s, o) strncmp((s), (o), NUM_ELEM(o) - 1)
88 #define MATCH_STR_I(s, o) _strnicmp((s), (o), NUM_ELEM(o) - 1)
89
90 /* This extension implements SSH, so we choose a load order in the
91 "protocols" range. */
92 #define ORDER 2500
93
94 static HICON SecureLargeIcon = NULL;
95 static HICON SecureSmallIcon = NULL;
96
97 static HFONT DlgHostFont;
98 static HFONT DlgAboutFont;
99 static HFONT DlgSetupFont;
100 static HFONT DlgKeygenFont;
101
102 static TInstVar FAR *pvar;
103
104 typedef struct {
105 int cnt;
106 HWND dlg;
107 ssh_keytype type;
108 } cbarg_t;
109
110 /* WIN32 allows multiple instances of a DLL */
111 static TInstVar InstVar;
112
113 /*
114 This code makes lots of assumptions about the order in which Tera Term
115 does things, and how. A key assumption is that the Notification window
116 passed into WSAAsyncSelect is the main terminal window. We also assume
117 that the socket used in the first WSAconnect is the main session socket.
118 */
119
120 static void init_TTSSH(PTInstVar pvar)
121 {
122 pvar->socket = INVALID_SOCKET;
123 pvar->OldLargeIcon = NULL;
124 pvar->OldSmallIcon = NULL;
125 pvar->NotificationWindow = NULL;
126 pvar->hostdlg_activated = FALSE;
127 pvar->socket = INVALID_SOCKET;
128 pvar->NotificationWindow = NULL;
129 pvar->protocol_major = 0;
130 pvar->protocol_minor = 0;
131
132 PKT_init(pvar);
133 SSH_init(pvar);
134 CRYPT_init(pvar);
135 AUTH_init(pvar);
136 HOSTS_init(pvar);
137 FWD_init(pvar);
138 FWDUI_init(pvar);
139
140 ssh_heartbeat_lock_initialize();
141 }
142
143 static void uninit_TTSSH(PTInstVar pvar)
144 {
145 halt_ssh_heartbeat_thread(pvar);
146
147 ssh2_channel_free();
148
149 SSH_end(pvar);
150 PKT_end(pvar);
151 AUTH_end(pvar);
152 CRYPT_end(pvar);
153 HOSTS_end(pvar);
154 FWD_end(pvar);
155 FWDUI_end(pvar);
156
157 if (pvar->OldLargeIcon != NULL) {
158 PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_BIG,
159 (LPARAM) pvar->OldLargeIcon);
160 pvar->OldLargeIcon = NULL;
161 }
162 if (pvar->OldSmallIcon != NULL) {
163 PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_SMALL,
164 (LPARAM) pvar->OldSmallIcon);
165 pvar->OldSmallIcon = NULL;
166 }
167
168 ssh_heartbeat_lock_finalize();
169 }
170
171 static void PASCAL FAR TTXInit(PTTSet ts, PComVar cv)
172 {
173 pvar->settings = *pvar->ts_SSH;
174 pvar->ts = ts;
175 pvar->cv = cv;
176 pvar->fatal_error = FALSE;
177 pvar->showing_err = FALSE;
178 pvar->err_msg = NULL;
179
180 init_TTSSH(pvar);
181 }
182
183 static void normalize_generic_order(char *buf, char default_strings[], int default_strings_len)
184 {
185 char listed[max(KEX_DH_MAX,max(SSH_CIPHER_MAX,max(KEY_MAX,max(HMAC_MAX,COMP_MAX)))) + 1];
186 char allowed[max(KEX_DH_MAX,max(SSH_CIPHER_MAX,max(KEY_MAX,max(HMAC_MAX,COMP_MAX)))) + 1];
187 int i, j;
188
189 memset(listed, 0, sizeof(listed));
190 memset(allowed, 0, sizeof(allowed));
191 for (i = 0; i < default_strings_len ; i++) {
192 allowed[default_strings[i]] = 1;
193 }
194
195 for (i = 0; buf[i] != 0; i++) {
196 int num = buf[i] - '0';
197
198 if (num < 0 || num > default_strings_len
199 || !allowed[num]
200 || listed[num]) {
201 memmove(buf + i, buf + i + 1, strlen(buf + i + 1) + 1);
202 i--;
203 } else {
204 listed[num] = 1;
205 }
206 }
207
208 for (j = 0; j < default_strings_len ; j++) {
209 int num = default_strings[j];
210
211 if (!listed[num]) {
212 buf[i] = num + '0';
213 i++;
214 }
215 }
216
217 buf[i] = 0;
218 }
219
220 /*
221 * Remove unsupported cipher or duplicated cipher.
222 * Add unspecified ciphers at the end of list.
223 */
224 static void normalize_cipher_order(char FAR * buf)
225 {
226 /* SSH_CIPHER_NONE means that all ciphers below that one are disabled.
227 We *never* allow no encryption. */
228 #if 0
229 static char default_strings[] = {
230 SSH_CIPHER_3DES,
231 SSH_CIPHER_NONE,
232 SSH_CIPHER_DES, SSH_CIPHER_BLOWFISH
233 };
234 #else
235 // for SSH2(yutaka)
236 static char default_strings[] = {
237 SSH2_CIPHER_CAMELLIA256_CTR,
238 SSH2_CIPHER_AES256_CTR,
239 SSH2_CIPHER_CAMELLIA256_CBC,
240 SSH2_CIPHER_AES256_CBC,
241 SSH2_CIPHER_CAMELLIA192_CTR,
242 SSH2_CIPHER_AES192_CTR,
243 SSH2_CIPHER_CAMELLIA192_CBC,
244 SSH2_CIPHER_AES192_CBC,
245 SSH2_CIPHER_CAMELLIA128_CTR,
246 SSH2_CIPHER_AES128_CTR,
247 SSH2_CIPHER_CAMELLIA128_CBC,
248 SSH2_CIPHER_AES128_CBC,
249 SSH2_CIPHER_3DES_CTR,
250 SSH2_CIPHER_3DES_CBC,
251 SSH2_CIPHER_BLOWFISH_CTR,
252 SSH2_CIPHER_BLOWFISH_CBC,
253 SSH2_CIPHER_ARCFOUR256,
254 SSH2_CIPHER_ARCFOUR128,
255 SSH2_CIPHER_ARCFOUR,
256 SSH2_CIPHER_CAST128_CTR,
257 SSH2_CIPHER_CAST128_CBC,
258 SSH_CIPHER_3DES,
259 SSH_CIPHER_NONE,
260 SSH_CIPHER_DES,
261 SSH_CIPHER_BLOWFISH,
262 0, 0, 0 // Dummy for SSH_CIPHER_IDEA, SSH_CIPHER_TSS, SSH_CIPHER_RC4
263 };
264 #endif
265
266 normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
267 }
268
269 static void normalize_kex_order(char FAR * buf)
270 {
271 static char default_strings[] = {
272 KEX_ECDH_SHA2_256,
273 KEX_ECDH_SHA2_384,
274 KEX_ECDH_SHA2_521,
275 KEX_DH_GEX_SHA256,
276 KEX_DH_GEX_SHA1,
277 KEX_DH_GRP14_SHA1,
278 KEX_DH_GRP1_SHA1,
279 KEX_DH_NONE,
280 };
281
282 normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
283 }
284
285 static void normalize_host_key_order(char FAR * buf)
286 {
287 static char default_strings[] = {
288 KEY_ECDSA256,
289 KEY_ECDSA384,
290 KEY_ECDSA521,
291 KEY_RSA,
292 KEY_DSA,
293 KEY_NONE,
294 };
295
296 normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
297 }
298
299 static void normalize_mac_order(char FAR * buf)
300 {
301 static char default_strings[] = {
302 HMAC_SHA2_512,
303 HMAC_SHA2_256,
304 HMAC_SHA1,
305 HMAC_RIPEMD160,
306 HMAC_MD5,
307 HMAC_NONE,
308 HMAC_SHA1_96,
309 HMAC_MD5_96,
310 0, // Dummy for HMAC_SHA2_512_96,
311 0, // Dummy for HMAC_SHA2_256_96,
312 };
313
314 normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
315 }
316
317 static void normalize_comp_order(char FAR * buf)
318 {
319 static char default_strings[] = {
320 COMP_DELAYED,
321 COMP_ZLIB,
322 COMP_NOCOMP,
323 COMP_NONE,
324 };
325
326 normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
327 }
328
329
330 /* Remove local settings from the shared memory block. */
331 static void clear_local_settings(PTInstVar pvar)
332 {
333 pvar->ts_SSH->TryDefaultAuth = FALSE;
334 }
335
336 static BOOL read_BOOL_option(PCHAR fileName, char FAR * keyName, BOOL def)
337 {
338 char buf[1024];
339
340 buf[0] = 0;
341 GetPrivateProfileString("TTSSH", keyName, "", buf, sizeof(buf),
342 fileName);
343 if (buf[0] == 0) {
344 return def;
345 } else {
346 return atoi(buf) != 0 ||
347 _stricmp(buf, "yes") == 0 ||
348 _stricmp(buf, "y") == 0;
349 }
350 }
351
352 static void read_string_option(PCHAR fileName, char FAR * keyName,
353 char FAR * def, char FAR * buf, int bufSize)
354 {
355
356 buf[0] = 0;
357 GetPrivateProfileString("TTSSH", keyName, def, buf, bufSize, fileName);
358 }
359
360 static void read_ssh_options(PTInstVar pvar, PCHAR fileName)
361 {
362 char buf[1024];
363 TS_SSH FAR *settings = pvar->ts_SSH;
364
365 #define READ_STD_STRING_OPTION(name) \
366 read_string_option(fileName, #name, "", settings->name, sizeof(settings->name))
367
368 settings->Enabled = read_BOOL_option(fileName, "Enabled", FALSE);
369
370 buf[0] = 0;
371 GetPrivateProfileString("TTSSH", "Compression", "", buf, sizeof(buf),
372 fileName);
373 settings->CompressionLevel = atoi(buf);
374 if (settings->CompressionLevel < 0 || settings->CompressionLevel > 9) {
375 settings->CompressionLevel = 0;
376 }
377
378 READ_STD_STRING_OPTION(DefaultUserName);
379 READ_STD_STRING_OPTION(DefaultForwarding);
380 READ_STD_STRING_OPTION(DefaultRhostsLocalUserName);
381 READ_STD_STRING_OPTION(DefaultRhostsHostPrivateKeyFile);
382 READ_STD_STRING_OPTION(DefaultRSAPrivateKeyFile);
383
384 READ_STD_STRING_OPTION(CipherOrder);
385 normalize_cipher_order(settings->CipherOrder);
386
387 // KEX order
388 READ_STD_STRING_OPTION(KexOrder);
389 normalize_kex_order(settings->KexOrder);
390 // Host Key algorithm order
391 READ_STD_STRING_OPTION(HostKeyOrder);
392 normalize_host_key_order(settings->HostKeyOrder);
393 // H-MAC order
394 READ_STD_STRING_OPTION(MacOrder);
395 normalize_mac_order(settings->MacOrder);
396 // Compression algorithm order
397 READ_STD_STRING_OPTION(CompOrder);
398 normalize_comp_order(settings->CompOrder);
399
400 read_string_option(fileName, "KnownHostsFiles", "ssh_known_hosts",
401 settings->KnownHostsFiles,
402 sizeof(settings->KnownHostsFiles));
403
404 buf[0] = 0;
405 GetPrivateProfileString("TTSSH", "DefaultAuthMethod", "", buf,
406 sizeof(buf), fileName);
407 settings->DefaultAuthMethod = atoi(buf);
408 if (settings->DefaultAuthMethod != SSH_AUTH_PASSWORD
409 && settings->DefaultAuthMethod != SSH_AUTH_RSA
410 && settings->DefaultAuthMethod != SSH_AUTH_TIS // add (2005.3.12 yutaka)
411 && settings->DefaultAuthMethod != SSH_AUTH_RHOSTS
412 && settings->DefaultAuthMethod != SSH_AUTH_PAGEANT) {
413 /* this default can never be SSH_AUTH_RHOSTS_RSA because that is not a
414 selection in the dialog box; SSH_AUTH_RHOSTS_RSA is automatically chosen
415 when the dialog box has rhosts selected and an host private key file
416 is supplied. */
417 settings->DefaultAuthMethod = SSH_AUTH_PASSWORD;
418 }
419
420 buf[0] = 0;
421 GetPrivateProfileString("TTSSH", "LogLevel", "", buf, sizeof(buf),
422 fileName);
423 settings->LogLevel = atoi(buf);
424
425 buf[0] = 0;
426 GetPrivateProfileString("TTSSH", "WriteBufferSize", "", buf,
427 sizeof(buf), fileName);
428 settings->WriteBufferSize = atoi(buf);
429 if (settings->WriteBufferSize <= 0) {
430 settings->WriteBufferSize = (PACKET_MAX_SIZE / 2); // 2MB
431 }
432
433 // SSH protocol version (2004.10.11 yutaka)
434 // default is SSH2 (2004.11.30 yutaka)
435 settings->ssh_protocol_version = GetPrivateProfileInt("TTSSH", "ProtocolVersion", 2, fileName);
436
437 // SSH heartbeat time(second) (2004.12.11 yutaka)
438 settings->ssh_heartbeat_overtime = GetPrivateProfileInt("TTSSH", "HeartBeat", 60, fileName);
439
440 // �p�X���[�h�F�����������J���F�����g���p�X���[�h����������������������������������
441 // �\���B(2006.8.5 yutaka)
442 settings->remember_password = GetPrivateProfileInt("TTSSH", "RememberPassword", 1, fileName);
443
444 // �������F���_�C�A���O���T�|�[�g�������������\�b�h���`�F�b�N���A
445 // ���������\�b�h���O���C�A�E�g���� (2007.9.24 maya)
446 settings->CheckAuthListFirst = read_BOOL_option(fileName, "CheckAuthListFirst", FALSE);
447
448 // 768bit ������ RSA ���������T�[�o�����������L�������� (2008.9.11 maya)
449 settings->EnableRsaShortKeyServer = read_BOOL_option(fileName, "EnableRsaShortKeyServer", FALSE);
450
451 // agent forward ���L�������� (2008.11.25 maya)
452 settings->ForwardAgent = read_BOOL_option(fileName, "ForwardAgent", FALSE);
453
454 // agent forward �m�F���L��������
455 settings->ForwardAgentConfirm = read_BOOL_option(fileName, "ForwardAgentConfirm", TRUE);
456
457 // �z�X�g���� DNS �����`�F�b�N (RFC 4255)
458 settings->VerifyHostKeyDNS = read_BOOL_option(fileName, "VerifyHostKeyDNS", TRUE);
459
460 // icon
461 GetPrivateProfileString("TTSSH", "SSHIcon", "", buf, sizeof(buf), fileName);
462 if ((_stricmp(buf, "old") == 0) ||
463 (_stricmp(buf, "yellow") == 0) ||
464 (_stricmp(buf, "securett_yellow") == 0)) {
465 settings->IconID = IDI_SECURETT_YELLOW;
466 }
467 else {
468 settings->IconID = IDI_SECURETT;
469 }
470
471 clear_local_settings(pvar);
472 }
473
474 static void write_ssh_options(PTInstVar pvar, PCHAR fileName,
475 TS_SSH FAR * settings, BOOL copy_forward)
476 {
477 char buf[1024];
478
479 WritePrivateProfileString("TTSSH", "Enabled",
480 settings->Enabled ? "1" : "0", fileName);
481
482 _itoa(settings->CompressionLevel, buf, 10);
483 WritePrivateProfileString("TTSSH", "Compression", buf, fileName);
484
485 WritePrivateProfileString("TTSSH", "DefaultUserName",
486 settings->DefaultUserName, fileName);
487
488 if (copy_forward) {
489 WritePrivateProfileString("TTSSH", "DefaultForwarding",
490 settings->DefaultForwarding, fileName);
491 }
492
493 WritePrivateProfileString("TTSSH", "CipherOrder",
494 settings->CipherOrder, fileName);
495
496 WritePrivateProfileString("TTSSH", "KexOrder",
497 settings->KexOrder, fileName);
498
499 WritePrivateProfileString("TTSSH", "HostKeyOrder",
500 settings->HostKeyOrder, fileName);
501
502 WritePrivateProfileString("TTSSH", "MacOrder",
503 settings->MacOrder, fileName);
504
505 WritePrivateProfileString("TTSSH", "CompOrder",
506 settings->CompOrder, fileName);
507
508 WritePrivateProfileString("TTSSH", "KnownHostsFiles",
509 settings->KnownHostsFiles, fileName);
510
511 WritePrivateProfileString("TTSSH", "DefaultRhostsLocalUserName",
512 settings->DefaultRhostsLocalUserName,
513 fileName);
514
515 WritePrivateProfileString("TTSSH", "DefaultRhostsHostPrivateKeyFile",
516 settings->DefaultRhostsHostPrivateKeyFile,
517 fileName);
518
519 WritePrivateProfileString("TTSSH", "DefaultRSAPrivateKeyFile",
520 settings->DefaultRSAPrivateKeyFile,
521 fileName);
522
523 _itoa(settings->DefaultAuthMethod, buf, 10);
524 WritePrivateProfileString("TTSSH", "DefaultAuthMethod", buf, fileName);
525
526 _itoa(settings->LogLevel, buf, 10);
527 WritePrivateProfileString("TTSSH", "LogLevel", buf, fileName);
528
529 _itoa(settings->WriteBufferSize, buf, 10);
530 WritePrivateProfileString("TTSSH", "WriteBufferSize", buf, fileName);
531
532 // SSH protocol version (2004.10.11 yutaka)
533 WritePrivateProfileString("TTSSH", "ProtocolVersion",
534 settings->ssh_protocol_version==2 ? "2" : "1",
535 fileName);
536
537 // SSH heartbeat time(second) (2004.12.11 yutaka)
538 _snprintf_s(buf, sizeof(buf), _TRUNCATE,
539 "%d", settings->ssh_heartbeat_overtime);
540 WritePrivateProfileString("TTSSH", "HeartBeat", buf, fileName);
541
542 // Remember password (2006.8.5 yutaka)
543 WritePrivateProfileString("TTSSH", "RememberPassword",
544 settings->remember_password ? "1" : "0",
545 fileName);
546
547 // �������F���_�C�A���O���T�|�[�g�������������\�b�h���`�F�b�N���A
548 // ���������\�b�h���O���C�A�E�g���� (2007.9.24 maya)
549 WritePrivateProfileString("TTSSH", "CheckAuthListFirst",
550 settings->CheckAuthListFirst ? "1" : "0", fileName);
551
552 // 768bit ������ RSA ���������T�[�o�����������L�������� (2008.9.11 maya)
553 WritePrivateProfileString("TTSSH", "EnableRsaShortKeyServer",
554 settings->EnableRsaShortKeyServer ? "1" : "0", fileName);
555
556 // agent forward ���L�������� (2008.11.25 maya)
557 WritePrivateProfileString("TTSSH", "ForwardAgent",
558 settings->ForwardAgent ? "1" : "0", fileName);
559
560 // agent forward �m�F���L��������
561 WritePrivateProfileString("TTSSH", "ForwardAgentConfirm",
562 settings->ForwardAgentConfirm ? "1" : "0", fileName);
563
564 // �z�X�g���� DNS �����`�F�b�N (RFC 4255)
565 WritePrivateProfileString("TTSSH", "VerifyHostKeyDNS",
566 settings->VerifyHostKeyDNS ? "1" : "0", fileName);
567
568 // SSH �A�C�R��
569 WritePrivateProfileString("TTSSH", "SSHIcon",
570 (settings->IconID==IDI_SECURETT_YELLOW) ? "yellow" : "Default", fileName);
571 }
572
573
574 /* find free port in all protocol family */
575 static unsigned short find_local_port(PTInstVar pvar)
576 {
577 int tries;
578 #ifndef NO_INET6
579 SOCKET connecter;
580 struct addrinfo hints;
581 struct addrinfo FAR *res;
582 struct addrinfo FAR *res0;
583 unsigned short port;
584 char pname[NI_MAXHOST];
585 #endif /* NO_INET6 */
586
587 if (pvar->session_settings.DefaultAuthMethod != SSH_AUTH_RHOSTS) {
588 return 0;
589 }
590
591 /* The random numbers here are only used to try to get fresh
592 ports across runs (dangling ports can cause bind errors
593 if we're unlucky). They do not need to be (and are not)
594 cryptographically strong.
595 */
596 srand((unsigned) GetTickCount());
597
598 #ifndef NO_INET6
599 for (tries = 20; tries > 0; tries--) {
600 memset(&hints, 0, sizeof(hints));
601 hints.ai_family = pvar->ts->ProtocolFamily;
602 hints.ai_flags = AI_PASSIVE;
603 hints.ai_socktype = SOCK_STREAM;
604 port = (unsigned) rand() % 512 + 512;
605 _snprintf_s(pname, sizeof(pname), _TRUNCATE, "%d", (int) port);
606 if (getaddrinfo(NULL, pname, &hints, &res0)) {
607 return 0;
608 /* NOT REACHED */
609 }
610
611 for (res = res0; res; res = res->ai_next) {
612 if (res->ai_family == AF_INET || res->ai_family == AF_INET6)
613 continue;
614
615 connecter =
616 socket(res->ai_family, res->ai_socktype, res->ai_protocol);
617 if (connecter == INVALID_SOCKET) {
618 freeaddrinfo(res0);
619 return 0;
620 }
621
622 if (bind(connecter, res->ai_addr, res->ai_addrlen) !=
623 SOCKET_ERROR) {
624 return port;
625 freeaddrinfo(res0);
626 closesocket(connecter);
627 } else if (WSAGetLastError() != WSAEADDRINUSE) {
628 closesocket(connecter);
629 freeaddrinfo(res0);
630 return 0;
631 }
632
633 closesocket(connecter);
634 }
635 freeaddrinfo(res0);
636 }
637
638 return 0;
639 #else
640 for (tries = 20; tries > 0; tries--) {
641 SOCKET connecter = socket(AF_INET, SOCK_STREAM, 0);
642 struct sockaddr_in connecter_addr;
643
644 connecter_addr.sin_family = AF_INET;
645 connecter_addr.sin_port = (unsigned) rand() % 512 + 512;
646 connecter_addr.sin_addr.s_addr = htonl(INADDR_ANY);
647
648 if (connecter == INVALID_SOCKET) {
649 return 0;
650 }
651
652 if (bind
653 (connecter, (struct sockaddr FAR *) &connecter_addr,
654 sizeof(connecter_addr)) != SOCKET_ERROR) {
655 closesocket(connecter);
656 return connecter_addr.sin_port;
657 } else if (WSAGetLastError() != WSAEADDRINUSE) {
658 closesocket(connecter);
659 return 0;
660 }
661
662 closesocket(connecter);
663 }
664
665 return 0;
666 #endif /* NO_INET6 */
667 }
668
669 static int PASCAL FAR TTXconnect(SOCKET s,
670 const struct sockaddr FAR * name,
671 int namelen)
672 {
673 #ifndef NO_INET6
674 if (pvar->socket == INVALID_SOCKET || pvar->socket != s) {
675 struct sockaddr_storage ss;
676 int len;
677
678 pvar->socket = s;
679
680 memset(&ss, 0, sizeof(ss));
681 switch (pvar->ts->ProtocolFamily) {
682 case AF_INET:
683 len = sizeof(struct sockaddr_in);
684 ((struct sockaddr_in FAR *) &ss)->sin_family = AF_INET;
685 ((struct sockaddr_in FAR *) &ss)->sin_addr.s_addr = INADDR_ANY;
686 ((struct sockaddr_in FAR *) &ss)->sin_port =
687 htons(find_local_port(pvar));
688 break;
689 case AF_INET6:
690 len = sizeof(struct sockaddr_in6);
691 ((struct sockaddr_in6 FAR *) &ss)->sin6_family = AF_INET6;
692 #if 0 /* symbol "in6addr_any" is not included in wsock32.lib */
693 /* if wsock32.lib will be linked, we can't refer "in6addr_any" */
694 ((struct sockaddr_in6 FAR *) &ss)->sin6_addr = in6addr_any;
695 #else
696 memset(&((struct sockaddr_in6 FAR *) &ss)->sin6_addr, 0,
697 sizeof(struct in_addr6));
698 #endif /* 0 */
699 ((struct sockaddr_in6 FAR *) &ss)->sin6_port =
700 htons(find_local_port(pvar));
701 break;
702 default:
703 /* UNSPEC */
704 break;
705 }
706
707 bind(s, (struct sockaddr FAR *) &ss, len);
708 }
709 #else
710 if (pvar->socket == INVALID_SOCKET) {
711 struct sockaddr_in addr;
712
713 pvar->socket = s;
714
715 addr.sin_family = AF_INET;
716 addr.sin_port = htons(find_local_port(pvar));
717 addr.sin_addr.s_addr = INADDR_ANY;
718 memset(addr.sin_zero, 0, sizeof(addr.sin_zero));
719
720 bind(s, (struct sockaddr FAR *) &addr, sizeof(addr));
721 }
722 #endif /* NO_INET6 */
723
724 return (pvar->Pconnect) (s, name, namelen);
725 }
726
727 static int PASCAL FAR TTXWSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg,
728 long lEvent)
729 {
730 if (s == pvar->socket) {
731 pvar->notification_events = lEvent;
732 pvar->notification_msg = wMsg;
733
734 if (pvar->NotificationWindow == NULL) {
735 pvar->NotificationWindow = hWnd;
736 AUTH_advance_to_next_cred(pvar);
737 }
738 }
739
740 return (pvar->PWSAAsyncSelect) (s, hWnd, wMsg, lEvent);
741 }
742
743 static int PASCAL FAR TTXrecv(SOCKET s, char FAR * buf, int len, int flags)
744 {
745 if (s == pvar->socket) {
746 int ret;
747
748 ssh_heartbeat_lock();
749 ret = PKT_recv(pvar, buf, len);
750 ssh_heartbeat_unlock();
751 return (ret);
752
753 } else {
754 return (pvar->Precv) (s, buf, len, flags);
755 }
756 }
757
758 static int PASCAL FAR TTXsend(SOCKET s, char const FAR * buf, int len,
759 int flags)
760 {
761 if (s == pvar->socket) {
762 ssh_heartbeat_lock();
763 SSH_send(pvar, buf, len);
764 ssh_heartbeat_unlock();
765 return len;
766 } else {
767 return (pvar->Psend) (s, buf, len, flags);
768 }
769 }
770
771 void notify_established_secure_connection(PTInstVar pvar)
772 {
773 int fuLoad = LR_DEFAULTCOLOR;
774
775 if (is_NT4()) {
776 fuLoad = LR_VGACOLOR;
777 }
778
779 // LoadIcon �������� LoadImage ���g�����������A
780 // 16x16 ���A�C�R���������I�������������������� (2006.8.9 maya)
781 if (SecureLargeIcon == NULL) {
782 SecureLargeIcon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
783 IMAGE_ICON, 0, 0, fuLoad);
784 }
785 if (SecureSmallIcon == NULL) {
786 SecureSmallIcon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
787 IMAGE_ICON, 16, 16, fuLoad);
788 }
789
790 if (SecureLargeIcon != NULL && SecureSmallIcon != NULL) {
791 #if 0
792 // �������A�C�R���� WNDCLASS ���Z�b�g�����������������o���������� (2006.8.10 maya)
793 pvar->OldLargeIcon =
794 (HICON) GetClassLong(pvar->NotificationWindow, GCL_HICON);
795 #else
796 // Tera Term ���� WM_SETICON �������������������������������o�� (2009.6.9 maya)
797 pvar->OldLargeIcon =
798 (HICON) SendMessage(pvar->NotificationWindow, WM_GETICON,
799 ICON_BIG, 0);
800 #endif
801 pvar->OldSmallIcon =
802 (HICON) SendMessage(pvar->NotificationWindow, WM_GETICON,
803 ICON_SMALL, 0);
804
805 PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_BIG,
806 (LPARAM) SecureLargeIcon);
807 PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_SMALL,
808 (LPARAM) SecureSmallIcon);
809 }
810
811 notify_verbose_message(pvar, "Entering secure mode",
812 LOG_LEVEL_VERBOSE);
813 }
814
815 void notify_closed_connection(PTInstVar pvar)
816 {
817 SSH_notify_disconnecting(pvar, NULL);
818 AUTH_notify_disconnecting(pvar);
819 HOSTS_notify_disconnecting(pvar);
820
821 PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
822 pvar->socket, MAKELPARAM(FD_CLOSE, 0));
823
824 }
825
826 static void add_err_msg(PTInstVar pvar, char FAR * msg)
827 {
828 if (pvar->err_msg != NULL) {
829 int buf_len = strlen(pvar->err_msg) + 3 + strlen(msg);
830 char FAR *buf = (char FAR *) malloc(buf_len);
831
832 strncpy_s(buf, buf_len, pvar->err_msg, _TRUNCATE);
833 strncat_s(buf, buf_len, "\n\n", _TRUNCATE);
834 strncat_s(buf, buf_len, msg, _TRUNCATE);
835 free(pvar->err_msg);
836 pvar->err_msg = buf;
837 } else {
838 pvar->err_msg = _strdup(msg);
839 }
840 }
841
842 void notify_nonfatal_error(PTInstVar pvar, char FAR * msg)
843 {
844 if (!pvar->showing_err) {
845 // �������������������m���E�B���h�E�����������A�f�X�N�g�b�v���I�[�i�[������
846 // ���b�Z�[�W�{�b�N�X���o���������B(2006.6.11 yutaka)
847 if (pvar->NotificationWindow == NULL) {
848 UTIL_get_lang_msg("MSG_ERROR_NONFAITAL", pvar,
849 "Tera Term: not fatal error");
850 MessageBox(NULL, msg, pvar->ts->UIMsg, MB_OK|MB_ICONINFORMATION);
851 msg[0] = '\0';
852
853 } else {
854 PostMessage(pvar->NotificationWindow, WM_COMMAND,
855 ID_SSHASYNCMESSAGEBOX, 0);
856 }
857 }
858 if (msg[0] != 0) {
859 notify_verbose_message(pvar, msg, LOG_LEVEL_ERROR);
860 add_err_msg(pvar, msg);
861 }
862 }
863
864 void notify_fatal_error(PTInstVar pvar, char FAR * msg)
865 {
866 if (msg[0] != 0) {
867 notify_verbose_message(pvar, msg, LOG_LEVEL_FATAL);
868 add_err_msg(pvar, msg);
869 }
870
871 if (!pvar->fatal_error) {
872 pvar->fatal_error = TRUE;
873
874 SSH_notify_disconnecting(pvar, msg);
875 AUTH_notify_disconnecting(pvar);
876 HOSTS_notify_disconnecting(pvar);
877
878 PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
879 pvar->socket, MAKELPARAM(FD_CLOSE,
880 (pvar->PWSAGetLastError) ()));
881 }
882 }
883
884 void notify_verbose_message(PTInstVar pvar, char FAR * msg, int level)
885 {
886 if (level <= pvar->session_settings.LogLevel) {
887 char buf[1024];
888 int file;
889
890 get_teraterm_dir_relative_name(buf, NUM_ELEM(buf), "TTSSH.LOG");
891 file = _open(buf, _O_RDWR | _O_APPEND | _O_CREAT | _O_TEXT,
892 _S_IREAD | _S_IWRITE);
893
894 if (file >= 0) {
895 char *strtime = mctimelocal();
896 DWORD processid;
897 char tmp[26];
898
899 _write(file, strtime, strlen(strtime));
900 GetWindowThreadProcessId(pvar->cv->HWin, &processid);
901 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, " [%lu] ",processid);
902 _write(file, tmp, strlen(tmp));
903 _write(file, msg, strlen(msg));
904 _write(file, "\n", 1);
905 _close(file);
906 }
907 }
908 }
909
910 static void PASCAL FAR TTXOpenTCP(TTXSockHooks FAR * hooks)
911 {
912 if (pvar->settings.Enabled) {
913 // TCPLocalEcho/TCPCRSend ������������ (maya 2007.4.25)
914 pvar->origDisableTCPEchoCR = pvar->ts->DisableTCPEchoCR;
915 pvar->ts->DisableTCPEchoCR = TRUE;
916
917 pvar->session_settings = pvar->settings;
918
919 notify_verbose_message(pvar, "---------------------------------------------------------------------", LOG_LEVEL_VERBOSE);
920 notify_verbose_message(pvar, "Initiating SSH session", LOG_LEVEL_VERBOSE);
921
922 FWDUI_load_settings(pvar);
923
924 pvar->cv->TelAutoDetect = FALSE;
925 /* This next line should not be needed because Tera Term's
926 CommLib should find ts->Telnet == 0 ... but we'll do this
927 just to be on the safe side. */
928 pvar->cv->TelFlag = FALSE;
929 pvar->cv->TelLineMode = FALSE;
930
931 pvar->Precv = *hooks->Precv;
932 pvar->Psend = *hooks->Psend;
933 pvar->PWSAAsyncSelect = *hooks->PWSAAsyncSelect;
934 pvar->Pconnect = *hooks->Pconnect;
935 pvar->PWSAGetLastError = *hooks->PWSAGetLastError;
936
937 *hooks->Precv = TTXrecv;
938 *hooks->Psend = TTXsend;
939 *hooks->PWSAAsyncSelect = TTXWSAAsyncSelect;
940 *hooks->Pconnect = TTXconnect;
941
942 SSH_open(pvar);
943 HOSTS_open(pvar);
944 FWDUI_open(pvar);
945
946 // ������ myproposal �����f���������A�������O�����������B (2006.6.26 maya)
947 SSH2_update_cipher_myproposal(pvar);
948 SSH2_update_kex_myproposal(pvar);
949 SSH2_update_host_key_myproposal(pvar);
950 SSH2_update_hmac_myproposal(pvar);
951 SSH2_update_compression_myproposal(pvar);
952 }
953 }
954
955 static void PASCAL FAR TTXCloseTCP(TTXSockHooks FAR * hooks)
956 {
957 if (pvar->session_settings.Enabled) {
958 pvar->socket = INVALID_SOCKET;
959
960 notify_verbose_message(pvar, "Terminating SSH session...",
961 LOG_LEVEL_VERBOSE);
962
963 *hooks->Precv = pvar->Precv;
964 *hooks->Psend = pvar->Psend;
965 *hooks->PWSAAsyncSelect = pvar->PWSAAsyncSelect;
966 *hooks->Pconnect = pvar->Pconnect;
967
968 pvar->ts->DisableTCPEchoCR = pvar->origDisableTCPEchoCR;
969 }
970
971 uninit_TTSSH(pvar);
972 init_TTSSH(pvar);
973 }
974
975 static void enable_dlg_items(HWND dlg, int from, int to, BOOL enabled)
976 {
977 for (; from <= to; from++) {
978 EnableWindow(GetDlgItem(dlg, from), enabled);
979 }
980 }
981
982 // C-p/C-n/C-b/C-f/C-a/C-e ���T�|�[�g (2007.9.5 maya)
983 // C-d/C-k ���T�|�[�g (2007.10.3 yutaka)
984 // �h���b�v�_�E���������G�f�B�b�g�R���g���[����
985 // �T�u�N���X�������������E�C���h�E�v���V�[�W��
986 WNDPROC OrigHostnameEditProc; // Original window procedure
987 LRESULT CALLBACK HostnameEditProc(HWND dlg, UINT msg,
988 WPARAM wParam, LPARAM lParam)
989 {
990 HWND parent;
991 int max, select, len;
992 char *str, *orgstr;
993
994 switch (msg) {
995 // �L�[�����������������m����
996 case WM_KEYDOWN:
997 if (GetKeyState(VK_CONTROL) < 0) {
998 switch (wParam) {
999 case 0x50: // Ctrl+p ... up
1000 parent = GetParent(dlg);
1001 select = SendMessage(parent, CB_GETCURSEL, 0, 0);
1002 if (select > 0) {
1003 PostMessage(parent, CB_SETCURSEL, select - 1, 0);
1004 }
1005 return 0;
1006 case 0x4e: // Ctrl+n ... down
1007 parent = GetParent(dlg);
1008 max = SendMessage(parent, CB_GETCOUNT, 0, 0);
1009 select = SendMessage(parent, CB_GETCURSEL, 0, 0);
1010 if (select < max - 1) {
1011 PostMessage(parent, CB_SETCURSEL, select + 1, 0);
1012 }
1013 return 0;
1014 case 0x42: // Ctrl+b ... left
1015 SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
1016 PostMessage(dlg, EM_SETSEL, select-1, select-1);
1017 return 0;
1018 case 0x46: // Ctrl+f ... right
1019 SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
1020 max = GetWindowTextLength(dlg) ;
1021 PostMessage(dlg, EM_SETSEL, select+1, select+1);
1022 return 0;
1023 case 0x41: // Ctrl+a ... home
1024 PostMessage(dlg, EM_SETSEL, 0, 0);
1025 return 0;
1026 case 0x45: // Ctrl+e ... end
1027 max = GetWindowTextLength(dlg) ;
1028 PostMessage(dlg, EM_SETSEL, max, max);
1029 return 0;
1030
1031 case 0x44: // Ctrl+d
1032 case 0x4b: // Ctrl+k
1033 case 0x55: // Ctrl+u
1034 SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
1035 max = GetWindowTextLength(dlg);
1036 max++; // '\0'
1037 orgstr = str = malloc(max);
1038 if (str != NULL) {
1039 len = GetWindowText(dlg, str, max);
1040 if (select >= 0 && select < len) {
1041 if (wParam == 0x44) { // �J�[�\���z����������������������
1042 memmove(&str[select], &str[select + 1], len - select - 1);
1043 str[len - 1] = '\0';
1044
1045 } else if (wParam == 0x4b) { // �J�[�\�������s��������������
1046 str[select] = '\0';
1047
1048 }
1049 }
1050
1051 if (wParam == 0x55) { // �J�[�\����������������������
1052 if (select >= len) {
1053 str[0] = '\0';
1054 } else {
1055 str = &str[select];
1056 }
1057 select = 0;
1058 }
1059
1060 SetWindowText(dlg, str);
1061 SendMessage(dlg, EM_SETSEL, select, select);
1062 free(orgstr);
1063 return 0;
1064 }
1065 break;
1066 }
1067 }
1068 break;
1069
1070 // �����L�[��������������������������������������������
1071 case WM_CHAR:
1072 switch (wParam) {
1073 case 0x01:
1074 case 0x02:
1075 case 0x04:
1076 case 0x05:
1077 case 0x06:
1078 case 0x0b:
1079 case 0x0e:
1080 case 0x10:
1081 case 0x15:
1082 return 0;
1083 }
1084 }
1085
1086 return CallWindowProc(OrigHostnameEditProc, dlg, msg, wParam, lParam);
1087 }
1088
1089 static BOOL CALLBACK TTXHostDlg(HWND dlg, UINT msg, WPARAM wParam,
1090 LPARAM lParam)
1091 {
1092 static char *ssh_version[] = {"SSH1", "SSH2", NULL};
1093 PGetHNRec GetHNRec;
1094 char EntName[128];
1095 char TempHost[HostNameMaxLength + 1];
1096 WORD i, j, w;
1097 WORD ComPortTable[MAXCOMPORT];
1098 static char *ComPortDesc[MAXCOMPORT];
1099 int comports;
1100 BOOL Ok;
1101 LOGFONT logfont;
1102 HFONT font;
1103 char uimsg[MAX_UIMSG];
1104 static HWND hwndHostname = NULL; // HOSTNAME dropdown
1105 static HWND hwndHostnameEdit = NULL; // Edit control on HOSTNAME dropdown
1106
1107 switch (msg) {
1108 case WM_INITDIALOG:
1109 GetHNRec = (PGetHNRec) lParam;
1110 SetWindowLong(dlg, DWL_USER, lParam);
1111
1112 GetWindowText(dlg, uimsg, sizeof(uimsg));
1113 UTIL_get_lang_msg("DLG_HOST_TITLE", pvar, uimsg);
1114 SetWindowText(dlg, pvar->ts->UIMsg);
1115 GetDlgItemText(dlg, IDC_HOSTNAMELABEL, uimsg, sizeof(uimsg));
1116 UTIL_get_lang_msg("DLG_HOST_TCPIPHOST", pvar, uimsg);
1117 SetDlgItemText(dlg, IDC_HOSTNAMELABEL, pvar->ts->UIMsg);
1118 GetDlgItemText(dlg, IDC_HISTORY, uimsg, sizeof(uimsg));
1119 UTIL_get_lang_msg("DLG_HOST_TCPIPHISTORY", pvar, uimsg);
1120 SetDlgItemText(dlg, IDC_HISTORY, pvar->ts->UIMsg);
1121 GetDlgItemText(dlg, IDC_SERVICELABEL, uimsg, sizeof(uimsg));
1122 UTIL_get_lang_msg("DLG_HOST_TCPIPSERVICE", pvar, uimsg);
1123 SetDlgItemText(dlg, IDC_SERVICELABEL, pvar->ts->UIMsg);
1124 GetDlgItemText(dlg, IDC_HOSTOTHER, uimsg, sizeof(uimsg));
1125 UTIL_get_lang_msg("DLG_HOST_TCPIPOTHER", pvar, uimsg);
1126 SetDlgItemText(dlg, IDC_HOSTOTHER, pvar->ts->UIMsg);
1127 GetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, uimsg, sizeof(uimsg));
1128 UTIL_get_lang_msg("DLG_HOST_TCPIPPORT", pvar, uimsg);
1129 SetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, pvar->ts->UIMsg);
1130 GetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, uimsg, sizeof(uimsg));
1131 UTIL_get_lang_msg("DLG_HOST_TCPIPSSHVERSION", pvar, uimsg);
1132 SetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, pvar->ts->UIMsg);
1133 GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, uimsg, sizeof(uimsg));
1134 UTIL_get_lang_msg("DLG_HOST_TCPIPPROTOCOL", pvar, uimsg);
1135 SetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, pvar->ts->UIMsg);
1136 GetDlgItemText(dlg, IDC_HOSTSERIAL, uimsg, sizeof(uimsg));
1137 UTIL_get_lang_msg("DLG_HOST_SERIAL", pvar, uimsg);
1138 SetDlgItemText(dlg, IDC_HOSTSERIAL, pvar->ts->UIMsg);
1139 GetDlgItemText(dlg, IDC_HOSTCOMLABEL, uimsg, sizeof(uimsg));
1140 UTIL_get_lang_msg("DLG_HOST_SERIALPORT", pvar, uimsg);
1141 SetDlgItemText(dlg, IDC_HOSTCOMLABEL, pvar->ts->UIMsg);
1142 GetDlgItemText(dlg, IDC_HOSTHELP, uimsg, sizeof(uimsg));
1143 UTIL_get_lang_msg("DLG_HOST_HELP", pvar, uimsg);
1144 SetDlgItemText(dlg, IDC_HOSTHELP, pvar->ts->UIMsg);
1145 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1146 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1147 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1148 GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
1149 UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
1150 SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1151
1152 // �z�X�g�q�X�g�����`�F�b�N�{�b�N�X������ (2005.10.21 yutaka)
1153 if (pvar->ts->HistoryList > 0) {
1154 SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_CHECKED, 0);
1155 } else {
1156 SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_UNCHECKED, 0);
1157 }
1158
1159 // �t�@�C�����������O�t���p�C�v�������ATCP/IP�����������B
1160 if (GetHNRec->PortType == IdFile ||
1161 GetHNRec->PortType == IdNamedPipe
1162 )
1163 GetHNRec->PortType = IdTCPIP;
1164
1165 strncpy_s(EntName, sizeof(EntName), "Host", _TRUNCATE);
1166
1167 i = 1;
1168 do {
1169 _snprintf_s(&EntName[4], sizeof(EntName)-4, _TRUNCATE, "%d", i);
1170 GetPrivateProfileString("Hosts", EntName, "",
1171 TempHost, sizeof(TempHost),
1172 GetHNRec->SetupFN);
1173 if (strlen(TempHost) > 0)
1174 SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_ADDSTRING,
1175 0, (LPARAM) TempHost);
1176 i++;
1177 } while (i <= MAXHOSTLIST);
1178
1179 SendDlgItemMessage(dlg, IDC_HOSTNAME, EM_LIMITTEXT,
1180 HostNameMaxLength - 1, 0);
1181
1182 SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_SETCURSEL, 0, 0);
1183
1184 // C-n/C-p ���������T�u�N���X�� (2007.9.4 maya)
1185 hwndHostname = GetDlgItem(dlg, IDC_HOSTNAME);
1186 hwndHostnameEdit = GetWindow(hwndHostname, GW_CHILD);
1187 OrigHostnameEditProc = (WNDPROC)GetWindowLong(hwndHostnameEdit, GWL_WNDPROC);
1188 SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)HostnameEditProc);
1189
1190 CheckRadioButton(dlg, IDC_HOSTTELNET, IDC_HOSTOTHER,
1191 pvar->settings.Enabled ? IDC_HOSTSSH : GetHNRec->
1192 Telnet ? IDC_HOSTTELNET : IDC_HOSTOTHER);
1193 SendDlgItemMessage(dlg, IDC_HOSTTCPPORT, EM_LIMITTEXT, 5, 0);
1194 SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TCPPort, FALSE);
1195 #ifndef NO_INET6
1196 for (i = 0; ProtocolFamilyList[i]; ++i) {
1197 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_ADDSTRING,
1198 0, (LPARAM) ProtocolFamilyList[i]);
1199 }
1200 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, EM_LIMITTEXT,
1201 ProtocolFamilyMaxLength - 1, 0);
1202 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_SETCURSEL, 0, 0);
1203 #endif /* NO_INET6 */
1204
1205 /////// SSH version
1206 for (i = 0; ssh_version[i]; ++i) {
1207 SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_ADDSTRING,
1208 0, (LPARAM) ssh_version[i]);
1209 }
1210 SendDlgItemMessage(dlg, IDC_SSH_VERSION, EM_LIMITTEXT,
1211 NUM_ELEM(ssh_version) - 1, 0);
1212
1213 if (pvar->settings.ssh_protocol_version == 1) {
1214 SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 0, 0); // SSH1
1215 } else {
1216 SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 1, 0); // SSH2
1217 }
1218
1219 if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1220 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE); // enabled
1221 } else {
1222 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1223 }
1224 /////// SSH version
1225
1226
1227 j = 0;
1228 w = 1;
1229 if ((comports=DetectComPorts(ComPortTable, GetHNRec->MaxComPort, ComPortDesc)) >= 0) {
1230 for (i=0; i<comports; i++) {
1231 // MaxComPort ���z�����|�[�g���\��������
1232 if (ComPortTable[i] > GetHNRec->MaxComPort) {
1233 continue;
1234 }
1235
1236 // �g�p�����|�[�g���\��������
1237 if (CheckCOMFlag(ComPortTable[i]) == 1) {
1238 continue;
1239 }
1240
1241 _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", ComPortTable[i]);
1242 if (ComPortDesc[i] != NULL) {
1243 strncat_s(EntName, sizeof(EntName), ": ", _TRUNCATE);
1244 strncat_s(EntName, sizeof(EntName), ComPortDesc[i], _TRUNCATE);
1245 }
1246 SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
1247 0, (LPARAM)EntName);
1248 j++;
1249 if (GetHNRec->ComPort == ComPortTable[i])
1250 w = j;
1251 }
1252
1253 } else {
1254 for (i = 1; i <= GetHNRec->MaxComPort; i++) {
1255 // �g�p�����|�[�g���\��������
1256 if (CheckCOMFlag(i) == 1) {
1257 continue;
1258 }
1259
1260 _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", i);
1261 SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
1262 0, (LPARAM) EntName);
1263 j++;
1264 if (GetHNRec->ComPort == i)
1265 w = j;
1266 }
1267 }
1268
1269 if (j > 0)
1270 SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_SETCURSEL, w - 1, 0);
1271 else { /* All com ports are already used */
1272 GetHNRec->PortType = IdTCPIP;
1273 enable_dlg_items(dlg, IDC_HOSTSERIAL, IDC_HOSTSERIAL, FALSE);
1274 }
1275
1276 CheckRadioButton(dlg, IDC_HOSTTCPIP, IDC_HOSTSERIAL,
1277 IDC_HOSTTCPIP + GetHNRec->PortType - 1);
1278
1279 if (GetHNRec->PortType == IdTCPIP) {
1280 enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);
1281
1282 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
1283 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE);
1284
1285 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, TRUE); // enabled
1286 }
1287 #ifndef NO_INET6
1288 else {
1289 enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1290 FALSE);
1291 enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1292 IDC_HOSTTCPPROTOCOL, FALSE);
1293
1294 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1295 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)
1296
1297 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, FALSE); // disabled
1298 }
1299 #else
1300 else
1301 enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1302 FALSE);
1303 #endif /* NO_INET6 */
1304
1305 // Host dialog���t�H�[�J�X�������� (2004.10.2 yutaka)
1306 if (GetHNRec->PortType == IdTCPIP) {
1307 HWND hwnd = GetDlgItem(dlg, IDC_HOSTNAME);
1308 SetFocus(hwnd);
1309 } else {
1310 HWND hwnd = GetDlgItem(dlg, IDC_HOSTCOM);
1311 SetFocus(hwnd);
1312 }
1313
1314 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1315 GetObject(font, sizeof(LOGFONT), &logfont);
1316 if (UTIL_get_lang_font("DLG_SYSTEM_FONT", dlg, &logfont, &DlgHostFont, pvar)) {
1317 SendDlgItemMessage(dlg, IDC_HOSTTCPIP, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1318 SendDlgItemMessage(dlg, IDC_HOSTNAMELABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1319 SendDlgItemMessage(dlg, IDC_HOSTNAME, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1320 SendDlgItemMessage(dlg, IDC_HISTORY, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1321 SendDlgItemMessage(dlg, IDC_SERVICELABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1322 SendDlgItemMessage(dlg, IDC_HOSTTELNET, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1323 SendDlgItemMessage(dlg, IDC_HOSTSSH, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1324 SendDlgItemMessage(dlg, IDC_HOSTOTHER, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1325 SendDlgItemMessage(dlg, IDC_HOSTTCPPORTLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1326 SendDlgItemMessage(dlg, IDC_HOSTTCPPORT, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1327 SendDlgItemMessage(dlg, IDC_SSH_VERSION_LABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1328 SendDlgItemMessage(dlg, IDC_SSH_VERSION, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1329 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOLLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1330 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1331 SendDlgItemMessage(dlg, IDC_HOSTSERIAL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1332 SendDlgItemMessage(dlg, IDC_HOSTCOMLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1333 SendDlgItemMessage(dlg, IDC_HOSTCOM, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1334 SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1335 SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1336 SendDlgItemMessage(dlg, IDC_HOSTHELP, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1337 }
1338 else {
1339 DlgHostFont = NULL;
1340 }
1341
1342 // SetFocus()���t�H�[�J�X���������������AFALSE�������K�v�������B
1343 // TRUE���������ATABSTOP�������������������R���g���[�����I�������B
1344 // (2004.11.23 yutaka)
1345 return FALSE;
1346 //return TRUE;
1347
1348 case WM_COMMAND:
1349 switch (LOWORD(wParam)) {
1350 case IDOK:
1351 GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);
1352 if (GetHNRec != NULL) {
1353 if (IsDlgButtonChecked(dlg, IDC_HOSTTCPIP)) {
1354 #ifndef NO_INET6
1355 char afstr[BUFSIZ];
1356 #endif /* NO_INET6 */
1357 i = GetDlgItemInt(dlg, IDC_HOSTTCPPORT, &Ok, FALSE);
1358 if (Ok) {
1359 GetHNRec->TCPPort = i;
1360 } else {
1361 UTIL_get_lang_msg("MSG_TCPPORT_NAN_ERROR", pvar,
1362 "The TCP port must be a number.");
1363 MessageBox(dlg, pvar->ts->UIMsg,
1364 "Tera Term", MB_OK | MB_ICONEXCLAMATION);
1365 return TRUE;
1366 }
1367 #ifndef NO_INET6
1368 #define getaf(str) \
1369 ((strcmp((str), "IPv6") == 0) ? AF_INET6 : \
1370 ((strcmp((str), "IPv4") == 0) ? AF_INET : AF_UNSPEC))
1371 memset(afstr, 0, sizeof(afstr));
1372 GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOL, afstr,
1373 sizeof(afstr));
1374 GetHNRec->ProtocolFamily = getaf(afstr);
1375 #endif /* NO_INET6 */
1376 GetHNRec->PortType = IdTCPIP;
1377 GetDlgItemText(dlg, IDC_HOSTNAME, GetHNRec->HostName,
1378 HostNameMaxLength);
1379 pvar->hostdlg_activated = TRUE;
1380 pvar->hostdlg_Enabled = FALSE;
1381 if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
1382 GetHNRec->Telnet = TRUE;
1383 } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1384 pvar->hostdlg_Enabled = TRUE;
1385
1386 // check SSH protocol version
1387 memset(afstr, 0, sizeof(afstr));
1388 GetDlgItemText(dlg, IDC_SSH_VERSION, afstr, sizeof(afstr));
1389 if (_stricmp(afstr, "SSH1") == 0) {
1390 pvar->settings.ssh_protocol_version = 1;
1391 } else {
1392 pvar->settings.ssh_protocol_version = 2;
1393 }
1394 }
1395 else { // IDC_HOSTOTHER
1396 GetHNRec->Telnet = FALSE;
1397 }
1398
1399 // host history check button
1400 if (SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_GETCHECK, 0, 0) == BST_CHECKED) {
1401 pvar->ts->HistoryList = 1;
1402 } else {
1403 pvar->ts->HistoryList = 0;
1404 }
1405
1406 } else {
1407 GetHNRec->PortType = IdSerial;
1408 GetHNRec->HostName[0] = 0;
1409 memset(EntName, 0, sizeof(EntName));
1410 GetDlgItemText(dlg, IDC_HOSTCOM, EntName,
1411 sizeof(EntName) - 1);
1412 if (strncmp(EntName, "COM", 3) == 0 && EntName[3] != '\0') {
1413 #if 0
1414 GetHNRec->ComPort = (BYTE) (EntName[3]) - 0x30;
1415 if (strlen(EntName) > 4)
1416 GetHNRec->ComPort =
1417 GetHNRec->ComPort * 10 + (BYTE) (EntName[4]) -
1418 0x30;
1419 #else
1420 GetHNRec->ComPort = atoi(&EntName[3]);
1421 #endif
1422 if (GetHNRec->ComPort > GetHNRec->MaxComPort)
1423 GetHNRec->ComPort = 1;
1424 } else {
1425 GetHNRec->ComPort = 1;
1426 }
1427 }
1428 }
1429 SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
1430 EndDialog(dlg, 1);
1431
1432 if (DlgHostFont != NULL) {
1433 DeleteObject(DlgHostFont);
1434 }
1435
1436 return TRUE;
1437
1438 case IDCANCEL:
1439 SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
1440 EndDialog(dlg, 0);
1441
1442 if (DlgHostFont != NULL) {
1443 DeleteObject(DlgHostFont);
1444 }
1445
1446 return TRUE;
1447
1448 case IDC_HOSTTCPIP:
1449 enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1450 TRUE);
1451 #ifndef NO_INET6
1452 enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1453 IDC_HOSTTCPPROTOCOL, TRUE);
1454 #endif /* NO_INET6 */
1455 enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);
1456
1457 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE); // disabled (2004.11.23 yutaka)
1458 if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1459 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
1460 } else {
1461 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1462 }
1463
1464 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, TRUE); // disabled
1465
1466 return TRUE;
1467
1468 case IDC_HOSTSERIAL:
1469 enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, TRUE);
1470 enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1471 FALSE);
1472 #ifndef NO_INET6
1473 enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1474 IDC_HOSTTCPPROTOCOL, FALSE);
1475 #endif /* NO_INET6 */
1476 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1477 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)
1478
1479 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, FALSE); // disabled
1480
1481 return TRUE;
1482
1483 case IDC_HOSTSSH:
1484 enable_dlg_items(dlg, IDC_SSH_VERSION,
1485 IDC_SSH_VERSION, TRUE);
1486 goto hostssh_enabled;
1487
1488 case IDC_HOSTTELNET:
1489 case IDC_HOSTOTHER:
1490 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1491 hostssh_enabled:
1492
1493 GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);
1494
1495 if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
1496 if (GetHNRec != NULL)
1497 SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TelPort,
1498 FALSE);
1499 } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1500 SetDlgItemInt(dlg, IDC_HOSTTCPPORT, 22, FALSE);
1501 }
1502 return TRUE;
1503
1504 case IDC_HOSTCOM:
1505 if(HIWORD(wParam) == CBN_DROPDOWN) {
1506 HWND hostcom = GetDlgItem(dlg, IDC_HOSTCOM);
1507 int count = SendMessage(hostcom, CB_GETCOUNT, 0, 0);
1508 int i, len, max_len = 0;
1509 char *lbl;
1510 HDC TmpDC = GetDC(hostcom);
1511 SIZE s;
1512 for (i=0; i<count; i++) {
1513 len = SendMessage(hostcom, CB_GETLBTEXTLEN, i, 0);
1514 lbl = (char *)calloc(len+1, sizeof(char));
1515 SendMessage(hostcom, CB_GETLBTEXT, i, (LPARAM)lbl);
1516 GetTextExtentPoint32(TmpDC, lbl, len, &s);
1517 if (s.cx > max_len)
1518 max_len = s.cx;
1519 free(lbl);
1520 }
1521 SendMessage(hostcom, CB_SETDROPPEDWIDTH,
1522 max_len + GetSystemMetrics(SM_CXVSCROLL), 0);
1523 }
1524 break;
1525
1526 case IDC_HOSTHELP:
1527 PostMessage(GetParent(dlg), WM_USER_DLGHELP2, 0, 0);
1528 }
1529 }
1530 return FALSE;
1531 }
1532
1533 static BOOL FAR PASCAL TTXGetHostName(HWND parent, PGetHNRec rec)
1534 {
1535 return (BOOL) DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_HOSTDLG),
1536 parent, TTXHostDlg, (LONG) rec);
1537 }
1538
1539 static void PASCAL FAR TTXGetUIHooks(TTXUIHooks FAR * hooks)
1540 {
1541 *hooks->GetHostName = TTXGetHostName;
1542 }
1543
1544 static void FAR PASCAL TTXReadINIFile(PCHAR fileName, PTTSet ts)
1545 {
1546 (pvar->ReadIniFile) (fileName, ts);
1547 read_ssh_options(pvar, fileName);
1548 pvar->settings = *pvar->ts_SSH;
1549 notify_verbose_message(pvar, "Reading INI file", LOG_LEVEL_VERBOSE);
1550 FWDUI_load_settings(pvar);
1551 }
1552
1553 static void FAR PASCAL TTXWriteINIFile(PCHAR fileName, PTTSet ts)
1554 {
1555 (pvar->WriteIniFile) (fileName, ts);
1556 *pvar->ts_SSH = pvar->settings;
1557 clear_local_settings(pvar);
1558 notify_verbose_message(pvar, "Writing INI file", LOG_LEVEL_VERBOSE);
1559 write_ssh_options(pvar, fileName, pvar->ts_SSH, TRUE);
1560 }
1561
1562 static void read_ssh_options_from_user_file(PTInstVar pvar,
1563 char FAR * user_file_name)
1564 {
1565 if (user_file_name[0] == '.') {
1566 read_ssh_options(pvar, user_file_name);
1567 } else {
1568 char buf[1024];
1569
1570 get_teraterm_dir_relative_name(buf, sizeof(buf), user_file_name);
1571 read_ssh_options(pvar, buf);
1572 }
1573
1574 pvar->settings = *pvar->ts_SSH;
1575 FWDUI_load_settings(pvar);
1576 }
1577
1578 #ifdef USE_ATCMDLINE
1579 // @���u�����N���u�������B (2005.1.26 yutaka)
1580 static void replace_to_blank(char *src, char *dst, int dst_len)
1581 {
1582 int len, i;
1583
1584 len = strlen(src);
1585 if (dst_len < len) // buffer overflow check
1586 return;
1587
1588 for (i = 0 ; i < len ; i++) {
1589 if (src[i] == '@') { // @ ���o��������
1590 if (i < len - 1 && src[i + 1] == '@') { // �������� @ �����A�b�g�}�[�N���F������
1591 *dst++ = '@';
1592 i++;
1593 } else {
1594 *dst++ = ' '; // �������u��������
1595 }
1596 } else {
1597 *dst++ = src[i];
1598 }
1599 }
1600 *dst = '\0';
1601 }
1602 #endif
1603
1604 // Percent-encode������������src���f�R�[�h����dst���R�s�[�����B
1605 // dstlen��dst���T�C�Y�B�����������������������A�����������������������B
1606 static void percent_decode(char *dst, int dstlen, char *src) {
1607 if (src == NULL || dst == NULL || dstlen < 1) {
1608 return;
1609 }
1610
1611 while (*src != 0 && dstlen > 1) {
1612 if (*src == '%' && isxdigit(*(src+1)) && isxdigit(*(src+2))) {
1613 src++; *dst = (isalpha(*src) ? (*src|0x20) - 'a' + 10 : *src - '0') << 4;
1614 src++; *dst |= (isalpha(*src) ? (*src|0x20) - 'a' + 10 : *src - '0');
1615 src++; dst++;
1616 }
1617 else {
1618 *dst++ = *src++;
1619 }
1620 dstlen--;
1621 }
1622 *dst = 0;
1623 return;
1624 }
1625
1626 /* returns 1 if the option text must be deleted */
1627 static int parse_option(PTInstVar pvar, char FAR * option)
1628 {
1629 if ((option[0] == '-' || option[0] == '/')) {
1630 if (MATCH_STR(option + 1, "ssh") == 0) {
1631 if (option[4] == 0) {
1632 pvar->settings.Enabled = 1;
1633 } else if (MATCH_STR(option + 4, "-L") == 0 ||
1634 MATCH_STR(option + 4, "-R") == 0 ||
1635 _stricmp(option + 4, "-X") == 0) {
1636 if (pvar->settings.DefaultForwarding[0] == 0) {
1637 strncpy_s(pvar->settings.DefaultForwarding,
1638 sizeof(pvar->settings.DefaultForwarding),
1639 option + 5, _TRUNCATE);
1640 } else {
1641 strncat_s(pvar->settings.DefaultForwarding,
1642 sizeof(pvar->settings.DefaultForwarding),
1643 ";", _TRUNCATE);
1644 strncat_s(pvar->settings.DefaultForwarding,
1645 sizeof(pvar->settings.DefaultForwarding),
1646 option + 5, _TRUNCATE);
1647 }
1648 } else if (MATCH_STR(option + 4, "-f=") == 0) {
1649 read_ssh_options_from_user_file(pvar, option + 7);
1650 } else if (MATCH_STR(option + 4, "-v") == 0) {
1651 pvar->settings.LogLevel = LOG_LEVEL_VERBOSE;
1652 } else if (_stricmp(option + 4, "-autologin") == 0 ||
1653 _stricmp(option + 4, "-autologon") == 0) {
1654 pvar->settings.TryDefaultAuth = TRUE;
1655 } else if (MATCH_STR_I(option + 4, "-agentconfirm=") == 0) {
1656 if ((_stricmp(option+18, "off") == 0) ||
1657 (_stricmp(option+18, "no") == 0) ||
1658 (_stricmp(option+18, "false") == 0) ||
1659 (_stricmp(option+18, "0") == 0) ||
1660 (_stricmp(option+18, "n") == 0)) {
1661 pvar->settings.ForwardAgentConfirm = 0;
1662 }
1663 else {
1664 pvar->settings.ForwardAgentConfirm = 1;
1665 }
1666
1667 // -axx������������������
1668 } else if (MATCH_STR(option + 4, "-a") == 0) {
1669 pvar->settings.ForwardAgent = FALSE;
1670 } else if (MATCH_STR(option + 4, "-A") == 0) {
1671 pvar->settings.ForwardAgent = TRUE;
1672
1673 } else if (MATCH_STR(option + 4, "-consume=") == 0) {
1674 read_ssh_options_from_user_file(pvar, option + 13);
1675 DeleteFile(option + 13);
1676
1677 } else if (MATCH_STR(option + 4, "-C=") == 0) {
1678 pvar->settings.CompressionLevel = atoi(option+7);
1679 if (pvar->settings.CompressionLevel < 0) {
1680 pvar->settings.CompressionLevel = 0;
1681 }
1682 else if (pvar->settings.CompressionLevel > 9) {
1683 pvar->settings.CompressionLevel = 9;
1684 }
1685 } else if (MATCH_STR(option + 4, "-C") == 0) {
1686 pvar->settings.CompressionLevel = 6;
1687 } else if (MATCH_STR(option + 4, "-c") == 0) {
1688 pvar->settings.CompressionLevel = 0;
1689 } else if (MATCH_STR_I(option + 4, "-icon=") == 0) {
1690 if ((_stricmp(option+10, "old") == 0) ||
1691 (_stricmp(option+10, "yellow") == 0) ||
1692 (_stricmp(option+10, "securett_yellow") == 0)) {
1693 pvar->settings.IconID = IDI_SECURETT_YELLOW;
1694 }
1695 else {
1696 pvar->settings.IconID = IDI_SECURETT;
1697 }
1698
1699 // /ssh1 �� /ssh2 �I�v�V�������V�K���� (2006.9.16 maya)
1700 } else if (MATCH_STR(option + 4, "1") == 0) {
1701 pvar->settings.Enabled = 1;
1702 pvar->settings.ssh_protocol_version = 1;
1703 } else if (MATCH_STR(option + 4, "2") == 0) {
1704 pvar->settings.Enabled = 1;
1705 pvar->settings.ssh_protocol_version = 2;
1706
1707 } else {
1708 char buf[1024];
1709
1710 UTIL_get_lang_msg("MSG_UNKNOWN_OPTION_ERROR", pvar,
1711 "Unrecognized command-line option: %s");
1712 _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg, option);
1713
1714 MessageBox(NULL, buf, "TTSSH", MB_OK | MB_ICONEXCLAMATION);
1715 }
1716
1717 // ttermpro.exe �� /T= �w�������p�������A������������ (2006.10.19 maya)
1718 } else if (MATCH_STR_I(option + 1, "t=") == 0) {
1719 if (strcmp(option + 3, "2") == 0) {
1720 pvar->settings.Enabled = 1;
1721 return OPTION_CLEAR; // /t=2��ttssh�������g������������
1722 } else {
1723 pvar->settings.Enabled = 0;
1724 return OPTION_NONE; // Tera Term������������������������
1725 }
1726
1727 // ttermpro.exe �� /F= �w������ TTSSH ������������ (2006.10.11 maya)
1728 } else if (MATCH_STR_I(option + 1, "f=") == 0) {
1729 read_ssh_options_from_user_file(pvar, option + 3);
1730 return OPTION_NONE; // Tera Term���������������K�v������������������
1731
1732 // /1 ������ /2 �I�v�V�������V�K���� (2004.10.3 yutaka)
1733 } else if (MATCH_STR(option + 1, "1") == 0) {
1734 // command line: /ssh /1 is SSH1 only
1735 pvar->settings.ssh_protocol_version = 1;
1736
1737 } else if (MATCH_STR(option + 1, "2") == 0) {
1738 // command line: /ssh /2 is SSH2 & SSH1
1739 pvar->settings.ssh_protocol_version = 2;
1740
1741 } else if (MATCH_STR(option + 1, "nossh") == 0) {
1742 // '/nossh' �I�v�V�����������B
1743 // TERATERM.INI ��SSH���L�������������������A������Cygterm���N��������������
1744 // �����������������B(2004.10.11 yutaka)
1745 pvar->settings.Enabled = 0;
1746
1747 } else if (MATCH_STR(option + 1, "telnet") == 0) {
1748 // '/telnet' ���w�������������������� '/nossh' ��������
1749 // SSH������������ (2006.9.16 maya)
1750 pvar->settings.Enabled = 0;
1751 // Tera Term �� Telnet �t���O���t����
1752 pvar->ts->Telnet = 1;
1753
1754 } else if (MATCH_STR(option + 1, "auth") == 0) {
1755 // SSH2�������O�C���I�v�V����������
1756 //
1757 // SYNOPSIS: /ssh /auth=passowrd /user=���[�U�� /passwd=�p�X���[�h
1758 // /ssh /auth=publickey /user=���[�U�� /passwd=�p�X���[�h /keyfile=�p�X
1759 // EXAMPLE: /ssh /auth=password /user=nike /passwd=a@bc
1760 // /ssh /auth=publickey /user=foo /passwd=bar /keyfile=d:\tmp\id_rsa
1761 // NOTICE: �p�X���[�h���p�X�������������������A�u�����N���������� @ ���g�������B
1762 //
1763 // (2004.11.30 yutaka)
1764 // (2005.1.26 yutaka) ���������B���J���F���T�|�[�g�B
1765 //
1766 pvar->ssh2_autologin = 1; // for SSH2 (2004.11.30 yutaka)
1767
1768 if (MATCH_STR(option + 5, "=password") == 0) { // �p�X���[�h
1769 //pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
1770 pvar->ssh2_authmethod = SSH_AUTH_PASSWORD;
1771
1772 // /auth=challenge ������ (2007.10.5 maya)
1773 } else if (MATCH_STR(option + 5, "=challenge") == 0) { // keyboard-interactive�F��
1774 //pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
1775 pvar->ssh2_authmethod = SSH_AUTH_TIS;
1776
1777 } else if (MATCH_STR(option + 5, "=publickey") == 0) { // ���J���F��
1778 //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1779 pvar->ssh2_authmethod = SSH_AUTH_RSA;
1780
1781 } else if (MATCH_STR(option + 5, "=pageant") == 0) { // ���J���F�� by Pageant
1782 //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1783 pvar->ssh2_authmethod = SSH_AUTH_PAGEANT;
1784
1785 } else {
1786 // TODO:
1787
1788 }
1789
1790 } else if (MATCH_STR(option + 1, "user=") == 0) {
1791 #ifdef USE_ATCMDLINE
1792 replace_to_blank(option + 6, pvar->ssh2_username, sizeof(pvar->ssh2_username));
1793 //_snprintf(pvar->ssh2_username, sizeof(pvar->ssh2_username), "%s", option + 6);
1794
1795 #else
1796 _snprintf_s(pvar->ssh2_username, sizeof(pvar->ssh2_username), _TRUNCATE, "%s", option + 6);
1797 #endif
1798
1799 } else if (MATCH_STR(option + 1, "passwd=") == 0) {
1800 #ifdef USE_ATCMDLINE
1801 replace_to_blank(option + 8, pvar->ssh2_password, sizeof(pvar->ssh2_password));
1802 //_snprintf(pvar->ssh2_password, sizeof(pvar->ssh2_password), "%s", option + 8);
1803 #else
1804 _snprintf_s(pvar->ssh2_password, sizeof(pvar->ssh2_password), _TRUNCATE, "%s", option + 8);
1805 #endif
1806
1807 } else if (MATCH_STR(option + 1, "keyfile=") == 0) {
1808 #ifdef USE_ATCMDLINE
1809 replace_to_blank(option + 9, pvar->ssh2_keyfile, sizeof(pvar->ssh2_keyfile));
1810 #else
1811 _snprintf_s(pvar->ssh2_keyfile, sizeof(pvar->ssh2_keyfile), _TRUNCATE, "%s", option + 9);
1812 #endif
1813
1814 } else if (MATCH_STR(option + 1, "ask4passwd") == 0) {
1815 // �p�X���[�h������ (2006.9.18 maya)
1816 pvar->ask4passwd = 1;
1817
1818 } else if (MATCH_STR(option + 1, "nosecuritywarning") == 0) {
1819 // known_hosts�`�F�b�N���������B���Y�I�v�V�������g�����A�Z�L�����e�B������������
1820 // �����A�B���I�v�V���������������B
1821 // (2009.10.4 yutaka)
1822 pvar->nocheck_known_hosts = TRUE;
1823
1824 }
1825 else { // Other (not ttssh) option
1826 return OPTION_NONE; // ttssh���I�v�V������������������������
1827 }
1828
1829 // �p�X���[�h�������������������O�C��������������
1830 // /auth ���F�����\�b�h���w�������������p������ (2006.9.18 maya)
1831 if (pvar->ask4passwd == 1) {
1832 pvar->ssh2_autologin = 0;
1833 }
1834 return OPTION_CLEAR;
1835
1836 }
1837 else if ((MATCH_STR_I(option, "ssh://") == 0) ||
1838 (MATCH_STR_I(option, "ssh1://") == 0) ||
1839 (MATCH_STR_I(option, "ssh2://") == 0) ||
1840 (MATCH_STR_I(option, "slogin://") == 0) ||
1841 (MATCH_STR_I(option, "slogin1://") == 0) ||
1842 (MATCH_STR_I(option, "slogin2://") == 0)) {
1843 //
1844 // ssh://user@host/ ����URL�`�����T�|�[�g
1845 // ���{�I�������� telnet:// URL��������
1846 //
1847 // �Q�l:
1848 // RFC3986: Uniform Resource Identifier (URI): Generic Syntax
1849 // RFC4248: The telnet URI Scheme
1850 //
1851 char *p, *p2, *p3;
1852 int optlen, hostlen;
1853
1854 optlen = strlen(option);
1855
1856 // ������':'���O�����������������������A������ssh�v���g�R���o�[�W������������
1857 p = _mbschr(option, ':');
1858 switch (*(p-1)) {
1859 case '1':
1860 pvar->settings.ssh_protocol_version = 1;
1861 break;
1862 case '2':
1863 pvar->settings.ssh_protocol_version = 2;
1864 break;
1865 }
1866
1867 // authority part �����|�C���^������
1868 p += 3;
1869
1870 // path part ������������
1871 if ((p2 = _mbschr(p, '/')) != NULL) {
1872 *p2 = 0;
1873 }
1874
1875 // '@'�������������A���������O�����[�U����
1876 if ((p2 = _mbschr(p, '@')) != NULL) {
1877 *p2 = 0;
1878 // ':'���~���p�X���[�h
1879 if ((p3 = _mbschr(p, ':')) != NULL) {
1880 *p3 = 0;
1881 percent_decode(pvar->ssh2_password, sizeof(pvar->ssh2_password), p3 + 1);
1882 }
1883 percent_decode(pvar->ssh2_username, sizeof(pvar->ssh2_username), p);
1884 // p �� host part ������('@'����������)����������������
1885 p = p2 + 1;
1886 }
1887
1888 // host part �� option �����������������Ascheme part ������
1889 // port�w����������������port���������������������m��������������
1890 hostlen = strlen(p);
1891 memmove_s(option, optlen, p, hostlen);
1892 option[hostlen] = 0;
1893
1894 // �|�[�g�w������������":22"������
1895 #ifndef NO_INET6
1896 if (option[0] == '[' && option[hostlen-1] == ']' || // IPv6 raw address without port
1897 option[0] != '[' && _mbschr(option, ':') == NULL) { // hostname or IPv4 raw address without port
1898 #else
1899 if (_mbschr(option, ':') == NULL) {
1900 #endif /* NO_INET6 */
1901 memcpy_s(option+hostlen, optlen-hostlen, ":22", 3);
1902 hostlen += 3;
1903 }
1904
1905 // �|�[�g�w�����������������X�y�[�X������
1906 memset(option+hostlen, ' ', optlen-hostlen);
1907
1908 pvar->settings.Enabled = 1;
1909
1910 return OPTION_REPLACE;
1911 }
1912 else if (_mbschr(option, '@') != NULL) {
1913 //
1914 // user@host �`�����T�|�[�g
1915 // ����������ssh�������T�|�[�g�����A���[�U����ttssh���������B
1916 // (ssh�������O -- ttssh�������W������������)
1917 // �����I��telnet authentication option���T�|�[�g��������
1918 // Tera Term�{�����������������������\���B
1919 //
1920 char *p;
1921 p = _mbschr(option, '@');
1922 *p = 0;
1923
1924 strncpy_s(pvar->ssh2_username, sizeof(pvar->ssh2_username), option, _TRUNCATE);
1925
1926 // ���[�U���������X�y�[�X�������B
1927 // ������TTX��Tera Term�{�������������������X�y�[�X�����������������A
1928 // �z�X�g�����������l�����K�v�������B
1929 memset(option, ' ', p-option+1);
1930
1931 return OPTION_REPLACE;
1932 }
1933
1934 return OPTION_NONE;
1935 }
1936
1937 static void FAR PASCAL TTXParseParam(PCHAR param, PTTSet ts,
1938 PCHAR DDETopic)
1939 {
1940 #ifndef USE_ATCMDLINE
1941 int i;
1942 BOOL inParam = FALSE;
1943 BOOL inQuotes = FALSE;
1944 BOOL inEqual = FALSE;
1945 int param_len=strlen(param);
1946 PCHAR start = NULL;
1947 char *buf = (char *)calloc(param_len+1, sizeof(char));
1948 int buflen = 0;
1949
1950 if (pvar->hostdlg_activated) {
1951 pvar->settings.Enabled = pvar->hostdlg_Enabled;
1952 }
1953
1954 for (i = 0; i < param_len; i++) {
1955 if (inQuotes) {
1956 // �������u��"����
1957 if (param[i] == '"') {
1958 if (param[i+1] == '"') {
1959 buf[buflen] = param[i];
1960 buflen++;
1961 i++;
1962 }
1963 else {
1964 // �N�H�[�g���������������������I����
1965 // "��buf�����������������n��
1966 switch (parse_option(pvar, buf)) {
1967 case OPTION_CLEAR:
1968 memset(start, ' ', (param + i) - start + 1);
1969 break;
1970 case OPTION_REPLACE:
1971 memset(start, ' ', (param + i) - start + 1);
1972 buflen = strlen(buf);
1973 memcpy(start, buf, buflen);
1974 break;
1975 }
1976 inParam = FALSE;
1977 inEqual = FALSE;
1978 start = NULL;
1979 memset(buf, 0, param_len);
1980 buflen = 0;
1981 inQuotes = FALSE;
1982 }
1983 }
1984 else {
1985 buf[buflen] = param[i];
1986 buflen++;
1987 }
1988 }
1989 else {
1990 if (!inParam) {
1991 // �����p�����[�^������������
1992 if (param[i] == '"') {
1993 // " ���n����
1994 start = param + i;
1995 inParam = TRUE;
1996 inQuotes = TRUE;
1997 }
1998 else if (param[i] != ' ' && param[i] != '\t') {
1999 // �������n����
2000 buf[buflen] = param[i];
2001 buflen++;
2002 start = param + i;
2003 inParam = TRUE;
2004 }
2005 }
2006 else {
2007 // �������u���p�����[�^����
2008 if (param[i] == ' ' || param[i] == '\t') {
2009 // �N�H�[�g�����������������������I����
2010 switch (parse_option(pvar, buf)) {
2011 case OPTION_CLEAR:
2012 memset(start, ' ', (param + i) - start + 1);
2013 break;
2014 case OPTION_REPLACE:
2015 memset(start, ' ', (param + i) - start + 1);
2016 buflen = strlen(buf);
2017 memcpy(start, buf, buflen);
2018 break;
2019 }
2020 inParam = FALSE;
2021 inEqual = FALSE;
2022 start = NULL;
2023 memset(buf, 0, param_len);
2024 buflen = 0;
2025 }
2026 else {
2027 buf[buflen] = param[i];
2028 buflen++;
2029 if (!inEqual && param[i] == '=') {
2030 inEqual = TRUE;
2031 if (param[i+1] == '"') {
2032 inQuotes = TRUE;
2033 i++;
2034 }
2035 }
2036 }
2037 }
2038 }
2039 }
2040
2041 // buf ���c�����������������n��
2042 // +1������������'\0'�������������������A��������������������
2043 if (strlen(buf) > 0) {
2044 switch (parse_option(pvar, buf)) {
2045 case OPTION_CLEAR:
2046 memset(start, ' ', (param + i) - start);
2047 break;
2048 case OPTION_REPLACE:
2049 memset(start, ' ', (param + i) - start);
2050 buflen = strlen(buf);
2051 memcpy(start, buf, buflen);
2052 break;
2053 }
2054 }
2055 free(buf);
2056 #else
2057 // �X�y�[�X�������t�@�C�������F�������������C�� (2006.10.7 maya)
2058 int i, buflen;
2059 BOOL inParam = FALSE;
2060 BOOL inQuotes = FALSE;
2061 BOOL inFileParam = FALSE;
2062 PCHAR option = NULL;
2063
2064 if (pvar->hostdlg_activated) {
2065 pvar->settings.Enabled = pvar->hostdlg_Enabled;
2066 }
2067
2068 for (i = 0; param[i] != 0; i++) {
2069 if (inQuotes ? param[i] == '"'
2070 : (param[i] == ' ' || param[i] == '\t')) {
2071 if (option != NULL) {
2072 char ch = param[i];
2073 PCHAR Equal;
2074
2075 param[i] = 0;
2076 Equal = strchr(option, '=');
2077 if (inFileParam && Equal != NULL && *(Equal + 1) == '"') {
2078 int buf_len = strlen(option) * sizeof(char);
2079 char *buf = (char *)calloc(strlen(option), sizeof(char));
2080 char c = option[Equal - option + 1];
2081 option[Equal - option + 1] = 0;
2082 strncat_s(buf, buf_len, option, _TRUNCATE);
2083 option[Equal - option + 1] = c;
2084 strncat_s(buf, buf_len, Equal + 2, _TRUNCATE);
2085 switch (parse_option(pvar, *buf == '"' ? buf + 1 : buf)) {
2086 case OPTION_CLEAR:
2087 memset(option, ' ', i + 1 - (option - param));
2088 break;
2089 case OPTION_REPLACE:
2090 buflen = strlen(buf);
2091 memcpy(option, buf, buflen);
2092 memset(option + buflen, ' ', i + 1 - buflen - (option - param));
2093 break;
2094 default:
2095 param[i] = ch;
2096 }
2097 free(buf);
2098 }
2099 else {
2100 switch (parse_option(pvar, *option == '"' ? option + 1 : option)) {
2101 case OPTION_CLEAR:
2102 memset(option, ' ', i + 1 - (option - param));
2103 break;
2104 default:
2105 param[i] = ch;
2106 }
2107 }
2108 option = NULL;
2109 }
2110 inParam = FALSE;
2111 inQuotes = FALSE;
2112 inFileParam = FALSE;
2113 } else if (!inParam) {
2114 if (param[i] == '"') {
2115 inQuotes = TRUE;
2116 inParam = TRUE;
2117 option = param + i;
2118 } else if (param[i] != ' ' && param[i] != '\t') {
2119 inParam = TRUE;
2120 option = param + i;
2121 }
2122 } else {
2123 if (option == NULL) {
2124 continue;
2125 }
2126 if ((option[0] == '-' || option[0] == '/') &&
2127 (MATCH_STR(option + 1, "ssh-f=") == 0 || // ttssh option
2128 MATCH_STR(option + 1, "ssh-consume=") == 0 || // ttssh option
2129 MATCH_STR_I(option + 1, "f=") == 0 || // Tera Term option
2130 MATCH_STR_I(option + 1, "fd=") == 0 || // Tera Term option
2131 MATCH_STR_I(option + 1, "k=") == 0 || // Tera Term option
2132 MATCH_STR_I(option + 1, "l=") == 0 || // Tera Term option
2133 MATCH_STR_I(option + 1, "m=") == 0 || // Tera Term option
2134 MATCH_STR_I(option + 1, "r=") == 0 || // Tera Term option
2135 MATCH_STR_I(option + 1, "w=") == 0 || // Tera Term option
2136 MATCH_STR(option + 1, "keyfile=") == 0)) { // ttssh option
2137 if (param[i] == '"') {
2138 inQuotes = TRUE;
2139 }
2140 inFileParam = TRUE;
2141 }
2142 }
2143 }
2144
2145 if (option != NULL) {
2146 PCHAR Equal = strchr(option, '=');
2147 if (inFileParam && Equal != NULL && *(Equal + 1) == '"') {
2148 int buf_len = strlen(option) * sizeof(char);
2149 char *buf = (char *)calloc(strlen(option), sizeof(char));
2150 char c = option[Equal - option + 1];
2151 option[Equal - option + 1] = 0;
2152 strncat_s(buf, buf_len, option, _TRUNCATE);
2153 option[Equal - option + 1] = c;
2154 strncat_s(buf, buf_len, Equal + 2, _TRUNCATE);
2155 switch (parse_option(pvar, *buf == '"' ? buf + 1 : buf)) {
2156 case OPTION_CLEAR:
2157 memset(option, ' ', i + 1 - (option - param));
2158 break;
2159 case OPTION_REPLACE:
2160 strcpy_s(option, i - (param - option), buf);
2161 break;
2162 }
2163 free(buf);
2164 }
2165 else {
2166 switch (parse_option(pvar, option)) {
2167 case OPTION_CLEAR:
2168 memset(option, ' ', i - (option - param));
2169 break;
2170 }
2171 }
2172 }
2173 #endif
2174
2175 FWDUI_load_settings(pvar);
2176
2177 (pvar->ParseParam) (param, ts, DDETopic);
2178
2179 }
2180
2181 static void PASCAL FAR TTXGetSetupHooks(TTXSetupHooks FAR * hooks)
2182 {
2183 pvar->ReadIniFile = *hooks->ReadIniFile;
2184 pvar->WriteIniFile = *hooks->WriteIniFile;
2185 pvar->ParseParam = *hooks->ParseParam;
2186
2187 *hooks->ReadIniFile = TTXReadINIFile;
2188 *hooks->WriteIniFile = TTXWriteINIFile;
2189 *hooks->ParseParam = TTXParseParam;
2190 }
2191
2192 static void PASCAL FAR TTXSetWinSize(int rows, int cols)
2193 {
2194 SSH_notify_win_size(pvar, cols, rows);
2195 }
2196
2197 static void insertMenuBeforeItem(HMENU menu, WORD beforeItemID, WORD flags,
2198 WORD newItemID, char FAR * text)
2199 {
2200 int i, j;
2201
2202 for (i = GetMenuItemCount(menu) - 1; i >= 0; i--) {
2203 HMENU submenu = GetSubMenu(menu, i);
2204
2205 for (j = GetMenuItemCount(submenu) - 1; j >= 0; j--) {
2206 if (GetMenuItemID(submenu, j) == beforeItemID) {
2207 InsertMenu(submenu, j, MF_BYPOSITION | flags, newItemID, text);
2208 return;
2209 }
2210 }
2211 }
2212 }
2213
2214 #define GetFileMenu(menu) GetSubMenuByChildID(menu, 50110) // ID_FILE_NEWCONNECTION
2215 #define GetEditMenu(menu) GetSubMenuByChildID(menu, 50210) // ID_EDIT_COPY2
2216 #define GetSetupMenu(menu) GetSubMenuByChildID(menu, 50310) // ID_SETUP_TERMINAL
2217 #define GetControlMenu(menu) GetSubMenuByChildID(menu, 50410) // ID_CONTROL_RESETTERMINAL
2218 #define GetHelpMenu(menu) GetSubMenuByChildID(menu, 50990) // ID_HELP_ABOUT
2219
2220 HMENU GetSubMenuByChildID(HMENU menu, UINT id) {
2221 int i, j, items, subitems, cur_id;
2222 HMENU m;
2223
2224 items = GetMenuItemCount(menu);
2225
2226 for (i=0; i<items; i++) {
2227 if (m = GetSubMenu(menu, i)) {
2228 subitems = GetMenuItemCount(m);
2229 for (j=0; j<subitems; j++) {
2230 cur_id = GetMenuItemID(m, j);
2231 if (cur_id == id) {
2232 return m;
2233 }
2234 }
2235 }
2236 }
2237 return NULL;
2238 }
2239
2240 static void PASCAL FAR TTXModifyMenu(HMENU menu)
2241 {
2242 pvar->FileMenu = GetFileMenu(menu);
2243
2244 /* inserts before ID_HELP_ABOUT */
2245 UTIL_get_lang_msg("MENU_ABOUT", pvar, "About &TTSSH...");
2246 insertMenuBeforeItem(menu, 50990, MF_ENABLED, ID_ABOUTMENU, pvar->ts->UIMsg);
2247
2248 /* inserts before ID_SETUP_TCPIP */
2249 UTIL_get_lang_msg("MENU_SSH", pvar, "SS&H...");
2250 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHSETUPMENU, pvar->ts->UIMsg);
2251 /* inserts before ID_SETUP_TCPIP */
2252 UTIL_get_lang_msg("MENU_SSH_AUTH", pvar, "SSH &Authentication...");
2253 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHAUTHSETUPMENU, pvar->ts->UIMsg);
2254 /* inserts before ID_SETUP_TCPIP */
2255 UTIL_get_lang_msg("MENU_SSH_FORWARD", pvar, "SSH F&orwarding...");
2256 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHFWDSETUPMENU, pvar->ts->UIMsg);
2257 UTIL_get_lang_msg("MENU_SSH_KEYGEN", pvar, "SSH KeyGe&nerator...");
2258 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHKEYGENMENU, pvar->ts->UIMsg);
2259
2260 /* inserts before ID_FILE_CHANGEDIR */
2261 UTIL_get_lang_msg("MENU_SSH_SCP", pvar, "SS&H SCP...");
2262 insertMenuBeforeItem(menu, 50170, MF_GRAYED, ID_SSHSCPMENU, pvar->ts->UIMsg);
2263 }
2264
2265 static void PASCAL FAR TTXModifyPopupMenu(HMENU menu) {
2266 if (menu == pvar->FileMenu) {
2267 if (pvar->cv->Ready && pvar->settings.Enabled)
2268 EnableMenuItem(menu, ID_SSHSCPMENU, MF_BYCOMMAND | MF_ENABLED);
2269 else
2270 EnableMenuItem(menu, ID_SSHSCPMENU, MF_BYCOMMAND | MF_GRAYED);
2271 }
2272 }
2273
2274 static void append_about_text(HWND dlg, char FAR * prefix, char FAR * msg)
2275 {
2276 SendDlgItemMessage(dlg, IDC_ABOUTTEXT, EM_REPLACESEL, 0,
2277 (LPARAM) prefix);
2278 SendDlgItemMessage(dlg, IDC_ABOUTTEXT, EM_REPLACESEL, 0, (LPARAM) msg);
2279 SendDlgItemMessage(dlg, IDC_ABOUTTEXT, EM_REPLACESEL, 0,
2280 (LPARAM) (char FAR *) "\r\n");
2281 }
2282
2283 // ���s�t�@�C�������o�[�W�������������� (2005.2.28 yutaka)
2284 void get_file_version(char *exefile, int *major, int *minor, int *release, int *build)
2285 {
2286 typedef struct {
2287 WORD wLanguage;
2288 WORD wCodePage;
2289 } LANGANDCODEPAGE, *LPLANGANDCODEPAGE;
2290 LPLANGANDCODEPAGE lplgcode;
2291 UINT unLen;
2292 DWORD size;
2293 char *buf = NULL;
2294 BOOL ret;
2295 int i;
2296 char fmt[80];
2297 char *pbuf;
2298
2299 size = GetFileVersionInfoSize(exefile, NULL);
2300 if (size == 0) {
2301 goto error;
2302 }
2303 buf = malloc(size);
2304 ZeroMemory(buf, size);
2305
2306 if (GetFileVersionInfo(exefile, 0, size, buf) == FALSE) {
2307 goto error;
2308 }
2309
2310 ret = VerQueryValue(buf,
2311 "\\VarFileInfo\\Translation",
2312 (LPVOID *)&lplgcode, &unLen);
2313 if (ret == FALSE)
2314 goto error;
2315
2316 for (i = 0 ; i < (int)(unLen / sizeof(LANGANDCODEPAGE)) ; i++) {
2317 _snprintf_s(fmt, sizeof(fmt), _TRUNCATE,
2318 "\\StringFileInfo\\%04x%04x\\FileVersion",
2319 lplgcode[i].wLanguage, lplgcode[i].wCodePage);
2320 VerQueryValue(buf, fmt, &pbuf, &unLen);
2321 if (unLen > 0) { // get success
2322 int n, a, b, c, d;
2323
2324 n = sscanf(pbuf, "%d, %d, %d, %d", &a, &b, &c, &d);
2325 if (n == 4) { // convert success
2326 *major = a;
2327 *minor = b;
2328 *release = c;
2329 *build = d;
2330 break;
2331 }
2332 }
2333 }
2334
2335 free(buf);
2336 return;
2337
2338 error:
2339 free(buf);
2340 *major = *minor = *release = *build = 0;
2341 }
2342
2343 static void init_about_dlg(PTInstVar pvar, HWND dlg)
2344 {
2345 char buf[1024];
2346 int a, b, c, d;
2347 char uimsg[MAX_UIMSG];
2348
2349 GetWindowText(dlg, uimsg, sizeof(uimsg));
2350 UTIL_get_lang_msg("DLG_ABOUT_TITLE", pvar, uimsg);
2351 SetWindowText(dlg, pvar->ts->UIMsg);
2352 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
2353 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
2354 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
2355
2356 // TTSSH���o�[�W�������������� (2005.2.28 yutaka)
2357 get_file_version("ttxssh.dll", &a, &b, &c, &d);
2358 _snprintf_s(buf, sizeof(buf), _TRUNCATE,
2359 "TTSSH\r\nTera Term Secure Shell extension, %d.%d", a, b);
2360 SendMessage(GetDlgItem(dlg, IDC_TTSSH_VERSION), WM_SETTEXT, 0, (LPARAM)buf);
2361
2362 // OpenSSL���o�[�W�������������� (2005.1.24 yutaka)
2363 // ���������� (2005.5.11 yutaka)
2364 #ifdef OPENSSL_VERSION_TEXT
2365 SendMessage(GetDlgItem(dlg, IDC_OPENSSL_VERSION), WM_SETTEXT, 0, (LPARAM)OPENSSL_VERSION_TEXT);
2366 #else
2367 SendMessage(GetDlgItem(dlg, IDC_OPENSSL_VERSION), WM_SETTEXT, 0, (LPARAM)"Unknown");
2368 #endif
2369
2370 // zlib���o�[�W�������������� (2005.5.11 yutaka)
2371 #ifdef ZLIB_VERSION
2372 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "ZLib %s", ZLIB_VERSION);
2373 #else
2374 _snprintf(buf, sizeof(buf), "ZLib Unknown");
2375 #endif
2376 SendMessage(GetDlgItem(dlg, IDC_ZLIB_VERSION), WM_SETTEXT, 0, (LPARAM)buf);
2377
2378 // PuTTY���o�[�W�������������� (2011.7.26 yutaka)
2379 #ifdef PUTTYVERSION
2380 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "PuTTY %s", PUTTYVERSION);
2381 #else
2382 _snprintf(buf, sizeof(buf), "PuTTY Unknown");
2383 #endif
2384 SendMessage(GetDlgItem(dlg, IDC_PUTTY_VERSION), WM_SETTEXT, 0, (LPARAM)buf);
2385
2386 // TTSSH�_�C�A���O���\������SSH������������ (2004.10.30 yutaka)
2387 if (pvar->socket != INVALID_SOCKET) {
2388 if (SSHv1(pvar)) {
2389 SSH_get_server_ID_info(pvar, buf, sizeof(buf));
2390 UTIL_get_lang_msg("DLG_ABOUT_SERVERID", pvar, "Server ID:");
2391 append_about_text(dlg, pvar->ts->UIMsg, buf);
2392 SSH_get_protocol_version_info(pvar, buf, sizeof(buf));
2393 UTIL_get_lang_msg("DLG_ABOUT_PROTOCOL", pvar, "Using protocol:");
2394 append_about_text(dlg, pvar->ts->UIMsg, buf);
2395 CRYPT_get_cipher_info(pvar, buf, sizeof(buf));
2396 UTIL_get_lang_msg("DLG_ABOUT_ENCRYPTION", pvar, "Encryption:");
2397 append_about_text(dlg, pvar->ts->UIMsg, buf);
2398 CRYPT_get_server_key_info(pvar, buf, sizeof(buf));
2399 UTIL_get_lang_msg("DLG_ABOUT_SERVERKEY", pvar, "Server keys:");
2400 append_about_text(dlg, pvar->ts->UIMsg, buf);
2401 AUTH_get_auth_info(pvar, buf, sizeof(buf));
2402 UTIL_get_lang_msg("DLG_ABOUT_AUTH", pvar, "Authentication:");
2403 append_about_text(dlg, pvar->ts->UIMsg, buf);
2404 SSH_get_compression_info(pvar, buf, sizeof(buf));
2405 UTIL_get_lang_msg("DLG_ABOUT_COMP", pvar, "Compression:");
2406 append_about_text(dlg, pvar->ts->UIMsg, buf);
2407
2408 } else { // SSH2
2409 SSH_get_server_ID_info(pvar, buf, sizeof(buf));
2410 UTIL_get_lang_msg("DLG_ABOUT_SERVERID", pvar, "Server ID:");
2411 append_about_text(dlg, pvar->ts->UIMsg, buf);
2412 UTIL_get_lang_msg("DLG_ABOUT_CLIENTID", pvar, "Client ID:");
2413 append_about_text(dlg, pvar->ts->UIMsg, pvar->client_version_string);
2414
2415 SSH_get_protocol_version_info(pvar, buf, sizeof(buf));
2416 UTIL_get_lang_msg("DLG_ABOUT_PROTOCOL", pvar, "Using protocol:");
2417 append_about_text(dlg, pvar->ts->UIMsg, buf);
2418
2419 append_about_text(dlg, "KEX:", get_kex_algorithm_name(pvar->kex_type));
2420
2421 strncpy_s(buf, sizeof(buf), get_ssh_keytype_name(pvar->hostkey_type), _TRUNCATE);
2422 UTIL_get_lang_msg("DLG_ABOUT_HOSTKEY", pvar, "Host Key:");
2423 append_about_text(dlg, pvar->ts->UIMsg, buf);
2424
2425 // add MAC algorithm (2004.12.17 yutaka)
2426 buf[0] = '\0';
2427 strncat_s(buf, sizeof(buf), get_ssh2_mac_name(pvar->ctos_hmac) , _TRUNCATE);
2428 UTIL_get_lang_msg("DLG_ABOUT_TOSERVER", pvar, " to server,");
2429 strncat_s(buf, sizeof(buf), pvar->ts->UIMsg, _TRUNCATE);
2430 strncat_s(buf, sizeof(buf), get_ssh2_mac_name(pvar->stoc_hmac) , _TRUNCATE);
2431 UTIL_get_lang_msg("DLG_ABOUT_FROMSERVER", pvar, " from server");
2432 strncat_s(buf, sizeof(buf), pvar->ts->UIMsg, _TRUNCATE);
2433 append_about_text(dlg, "MAC:", buf);
2434
2435 CRYPT_get_cipher_info(pvar, buf, sizeof(buf));
2436 UTIL_get_lang_msg("DLG_ABOUT_ENCRYPTION", pvar, "Encryption:");
2437 append_about_text(dlg, pvar->ts->UIMsg, buf);
2438 CRYPT_get_server_key_info(pvar, buf, sizeof(buf));
2439 UTIL_get_lang_msg("DLG_ABOUT_KEXKEY", pvar, "Key exchange keys:");
2440 append_about_text(dlg, pvar->ts->UIMsg, buf);
2441
2442 AUTH_get_auth_info(pvar, buf, sizeof(buf));
2443 UTIL_get_lang_msg("DLG_ABOUT_AUTH", pvar, "Authentication:");
2444 append_about_text(dlg, pvar->ts->UIMsg, buf);
2445
2446 SSH_get_compression_info(pvar, buf, sizeof(buf));
2447 if (pvar->ctos_compression == COMP_DELAYED) { // �x���p�P�b�g���k������ (2006.6.23 yutaka)
2448 UTIL_get_lang_msg("DLG_ABOUT_COMPDELAY", pvar, "Delayed Compression:");
2449 append_about_text(dlg, pvar->ts->UIMsg, buf);
2450 } else {
2451 UTIL_get_lang_msg("DLG_ABOUT_COMP", pvar, "Compression:");
2452 append_about_text(dlg, pvar->ts->UIMsg, buf);
2453 }
2454 }
2455 }
2456 }
2457
2458 static BOOL CALLBACK TTXAboutDlg(HWND dlg, UINT msg, WPARAM wParam,
2459 LPARAM lParam)
2460 {
2461 LOGFONT logfont;
2462 HFONT font;
2463
2464 switch (msg) {
2465 case WM_INITDIALOG:
2466 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
2467 GetObject(font, sizeof(LOGFONT), &logfont);
2468 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAboutFont, pvar)) {
2469 SendDlgItemMessage(dlg, IDC_TTSSH_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2470 SendDlgItemMessage(dlg, IDC_SSHVERSIONS, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2471 SendDlgItemMessage(dlg, IDC_INCLUDES, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2472 SendDlgItemMessage(dlg, IDC_OPENSSL_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2473 SendDlgItemMessage(dlg, IDC_ZLIB_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2474 SendDlgItemMessage(dlg, IDC_WEBSITES, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2475 SendDlgItemMessage(dlg, IDC_CRYPTOGRAPHY, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2476 SendDlgItemMessage(dlg, IDC_CREDIT, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2477 SendDlgItemMessage(dlg, IDC_ABOUTTEXT, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2478 SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2479 }
2480 else {
2481 DlgAboutFont = NULL;
2482 }
2483
2484 // �A�C�R�������I���Z�b�g
2485 {
2486 int fuLoad = LR_DEFAULTCOLOR;
2487 HICON hicon;
2488
2489 if (is_NT4()) {
2490 fuLoad = LR_VGACOLOR;
2491 }
2492
2493 hicon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
2494 IMAGE_ICON, 32, 32, fuLoad);
2495 SendDlgItemMessage(dlg, IDC_TTSSH_ICON, STM_SETICON, (WPARAM)hicon, 0);
2496 }
2497
2498 init_about_dlg((PTInstVar) lParam, dlg);
2499 SetFocus(GetDlgItem(dlg, IDOK));
2500 return FALSE;
2501 case WM_COMMAND:
2502 switch (LOWORD(wParam)) {
2503 case IDOK:
2504 EndDialog(dlg, 1);
2505 if (DlgAboutFont != NULL) {
2506 DeleteObject(DlgAboutFont);
2507 }
2508 return TRUE;
2509 case IDCANCEL: /* there isn't a cancel button, but other Windows
2510 UI things can send this message */
2511 EndDialog(dlg, 0);
2512 if (DlgAboutFont != NULL) {
2513 DeleteObject(DlgAboutFont);
2514 }
2515 return TRUE;
2516 }
2517 break;
2518 }
2519
2520 return FALSE;
2521 }
2522
2523 static char FAR *get_cipher_name(int cipher)
2524 {
2525 switch (cipher) {
2526 case SSH_CIPHER_NONE:
2527 UTIL_get_lang_msg("DLG_SSHSETUP_CIPHER_BORDER", pvar,
2528 "<ciphers below this line are disabled>");
2529 return pvar->ts->UIMsg;
2530 case SSH_CIPHER_RC4:
2531 return "RC4(SSH1)";
2532 case SSH_CIPHER_3DES:
2533 return "3DES(SSH1)";
2534 case SSH_CIPHER_DES:
2535 return "DES(SSH1)";
2536 case SSH_CIPHER_IDEA:
2537 return "IDEA(SSH1)";
2538 case SSH_CIPHER_TSS:
2539 return "TSS(SSH1)";
2540 case SSH_CIPHER_BLOWFISH:
2541 return "Blowfish(SSH1)";
2542
2543 // for SSH2(yutaka)
2544 case SSH2_CIPHER_AES128_CBC:
2545 return "AES128-CBC(SSH2)";
2546 case SSH2_CIPHER_AES192_CBC:
2547 return "AES192-CBC(SSH2)";
2548 case SSH2_CIPHER_AES256_CBC:
2549 return "AES256-CBC(SSH2)";
2550 case SSH2_CIPHER_3DES_CBC:
2551 return "3DES-CBC(SSH2)";
2552 case SSH2_CIPHER_BLOWFISH_CBC:
2553 return "Blowfish-CBC(SSH2)";
2554 case SSH2_CIPHER_AES128_CTR:
2555 return "AES128-CTR(SSH2)";
2556 case SSH2_CIPHER_AES192_CTR:
2557 return "AES192-CTR(SSH2)";
2558 case SSH2_CIPHER_AES256_CTR:
2559 return "AES256-CTR(SSH2)";
2560 case SSH2_CIPHER_ARCFOUR:
2561 return "Arcfour(SSH2)";
2562 case SSH2_CIPHER_ARCFOUR128:
2563 return "Arcfour128(SSH2)";
2564 case SSH2_CIPHER_ARCFOUR256:
2565 return "Arcfour256(SSH2)";
2566 case SSH2_CIPHER_CAST128_CBC:
2567 return "CAST128-CBC(SSH2)";
2568 case SSH2_CIPHER_3DES_CTR:
2569 return "3DES-CTR(SSH2)";
2570 case SSH2_CIPHER_BLOWFISH_CTR:
2571 return "Blowfish-CTR(SSH2)";
2572 case SSH2_CIPHER_CAST128_CTR:
2573 return "CAST128-CTR(SSH2)";
2574 case SSH2_CIPHER_CAMELLIA128_CBC:
2575 return "Camellia128-CBC(SSH2)";
2576 case SSH2_CIPHER_CAMELLIA192_CBC:
2577 return "Camellia192-CBC(SSH2)";
2578 case SSH2_CIPHER_CAMELLIA256_CBC:
2579 return "Camellia256-CBC(SSH2)";
2580 case SSH2_CIPHER_CAMELLIA128_CTR:
2581 return "Camellia128-CTR(SSH2)";
2582 case SSH2_CIPHER_CAMELLIA192_CTR:
2583 return "Camellia192-CTR(SSH2)";
2584 case SSH2_CIPHER_CAMELLIA256_CTR:
2585 return "Camellia256-CTR(SSH2)";
2586
2587 default:
2588 return NULL;
2589 }
2590 }
2591
2592 static void set_move_button_status(HWND dlg, int type, int up, int down)
2593 {
2594 HWND cipherControl = GetDlgItem(dlg, type);
2595 int curPos = (int) SendMessage(cipherControl, LB_GETCURSEL, 0, 0);
2596 int maxPos = (int) SendMessage(cipherControl, LB_GETCOUNT, 0, 0) - 1;
2597
2598 EnableWindow(GetDlgItem(dlg, up),
2599 curPos > 0 && curPos <= maxPos);
2600 EnableWindow(GetDlgItem(dlg, down),
2601 curPos >= 0 && curPos < maxPos);
2602 }
2603
2604 static void init_setup_dlg(PTInstVar pvar, HWND dlg)
2605 {
2606 HWND compressionControl = GetDlgItem(dlg, IDC_SSHCOMPRESSIONLEVEL);
2607 HWND cipherControl = GetDlgItem(dlg, IDC_SSHCIPHERPREFS);
2608 HWND kexControl = GetDlgItem(dlg, IDC_SSHKEX_LIST);
2609 HWND hostkeyControl = GetDlgItem(dlg, IDC_SSHHOST_KEY_LIST);
2610 HWND macControl = GetDlgItem(dlg, IDC_SSHMAC_LIST);
2611 HWND compControl = GetDlgItem(dlg, IDC_SSHCOMP_LIST);
2612 int i;
2613 int ch;
2614 char uimsg[MAX_UIMSG];
2615
2616 GetWindowText(dlg, uimsg, sizeof(uimsg));
2617 UTIL_get_lang_msg("DLG_SSHSETUP_TITLE", pvar, uimsg);
2618 SetWindowText(dlg, pvar->ts->UIMsg);
2619 GetDlgItemText(dlg, IDC_COMPRESSLABEL, uimsg, sizeof(uimsg));
2620 UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS", pvar, uimsg);
2621 SetDlgItemText(dlg, IDC_COMPRESSLABEL, pvar->ts->UIMsg);
2622 GetDlgItemText(dlg, IDC_COMPRESSNONE, uimsg, sizeof(uimsg));
2623 UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS_NONE", pvar, uimsg);
2624 SetDlgItemText(dlg, IDC_COMPRESSNONE, pvar->ts->UIMsg);
2625 GetDlgItemText(dlg, IDC_COMPRESSHIGH, uimsg, sizeof(uimsg));
2626 UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS_HIGHEST", pvar, uimsg);
2627 SetDlgItemText(dlg, IDC_COMPRESSHIGH, pvar->ts->UIMsg);
2628 GetDlgItemText(dlg, IDC_COMPRESSNOTE, uimsg, sizeof(uimsg));
2629 UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS_NOTE", pvar, uimsg);
2630 SetDlgItemText(dlg, IDC_COMPRESSNOTE, pvar->ts->UIMsg);
2631
2632 GetDlgItemText(dlg, IDC_CIPHERORDER, uimsg, sizeof(uimsg));
2633 UTIL_get_lang_msg("DLG_SSHSETUP_CHIPER", pvar, uimsg);
2634 SetDlgItemText(dlg, IDC_CIPHERORDER, pvar->ts->UIMsg);
2635 GetDlgItemText(dlg, IDC_SSHMOVECIPHERUP, uimsg, sizeof(uimsg));
2636 UTIL_get_lang_msg("DLG_SSHSETUP_CHIPER_UP", pvar, uimsg);
2637 SetDlgItemText(dlg, IDC_SSHMOVECIPHERUP, pvar->ts->UIMsg);
2638 GetDlgItemText(dlg, IDC_SSHMOVECIPHERDOWN, uimsg, sizeof(uimsg));
2639 UTIL_get_lang_msg("DLG_SSHSETUP_CHIPER_DOWN", pvar, uimsg);
2640 SetDlgItemText(dlg, IDC_SSHMOVECIPHERDOWN, pvar->ts->UIMsg);
2641
2642 GetDlgItemText(dlg, IDC_KEX_ORDER, uimsg, sizeof(uimsg));
2643 UTIL_get_lang_msg("DLG_SSHSETUP_KEX", pvar, uimsg);
2644 SetDlgItemText(dlg, IDC_KEX_ORDER, pvar->ts->UIMsg);
2645 GetDlgItemText(dlg, IDC_SSHKEX_MOVEUP, uimsg, sizeof(uimsg));
2646 UTIL_get_lang_msg("DLG_SSHSETUP_KEX_UP", pvar, uimsg);
2647 SetDlgItemText(dlg, IDC_SSHKEX_MOVEUP, pvar->ts->UIMsg);
2648 GetDlgItemText(dlg, IDC_SSHKEX_MOVEDOWN, uimsg, sizeof(uimsg));
2649 UTIL_get_lang_msg("DLG_SSHSETUP_KEX_DOWN", pvar, uimsg);
2650 SetDlgItemText(dlg, IDC_SSHKEX_MOVEDOWN, pvar->ts->UIMsg);
2651
2652 GetDlgItemText(dlg, IDC_HOST_KEY_ORDER, uimsg, sizeof(uimsg));
2653 UTIL_get_lang_msg("DLG_SSHSETUP_HOST_KEY", pvar, uimsg);
2654 SetDlgItemText(dlg, IDC_HOST_KEY_ORDER, pvar->ts->UIMsg);
2655 GetDlgItemText(dlg, IDC_SSHHOST_KEY_MOVEUP, uimsg, sizeof(uimsg));
2656 UTIL_get_lang_msg("DLG_SSHSETUP_HOST_KEY_UP", pvar, uimsg);
2657 SetDlgItemText(dlg, IDC_SSHHOST_KEY_MOVEUP, pvar->ts->UIMsg);
2658 GetDlgItemText(dlg, IDC_SSHHOST_KEY_MOVEDOWN, uimsg, sizeof(uimsg));
2659 UTIL_get_lang_msg("DLG_SSHSETUP_HOST_KEY_DOWN", pvar, uimsg);
2660 SetDlgItemText(dlg, IDC_SSHHOST_KEY_MOVEDOWN, pvar->ts->UIMsg);
2661
2662 GetDlgItemText(dlg, IDC_MAC_ORDER, uimsg, sizeof(uimsg));
2663 UTIL_get_lang_msg("DLG_SSHSETUP_MAC", pvar, uimsg);
2664 SetDlgItemText(dlg, IDC_MAC_ORDER, pvar->ts->UIMsg);
2665 GetDlgItemText(dlg, IDC_SSHMAC_MOVEUP, uimsg, sizeof(uimsg));
2666 UTIL_get_lang_msg("DLG_SSHSETUP_MAC_UP", pvar, uimsg);
2667 SetDlgItemText(dlg, IDC_SSHMAC_MOVEUP, pvar->ts->UIMsg);
2668 GetDlgItemText(dlg, IDC_SSHMAC_MOVEDOWN, uimsg, sizeof(uimsg));
2669 UTIL_get_lang_msg("DLG_SSHSETUP_MAC_DOWN", pvar, uimsg);
2670 SetDlgItemText(dlg, IDC_SSHMAC_MOVEDOWN, pvar->ts->UIMsg);
2671
2672 GetDlgItemText(dlg, IDC_COMP_ORDER, uimsg, sizeof(uimsg));
2673 UTIL_get_lang_msg("DLG_SSHSETUP_COMP", pvar, uimsg);
2674 SetDlgItemText(dlg, IDC_COMP_ORDER, pvar->ts->UIMsg);
2675 GetDlgItemText(dlg, IDC_SSHCOMP_MOVEUP, uimsg, sizeof(uimsg));
2676 UTIL_get_lang_msg("DLG_SSHSETUP_COMP_UP", pvar, uimsg);
2677 SetDlgItemText(dlg, IDC_SSHCOMP_MOVEUP, pvar->ts->UIMsg);
2678 GetDlgItemText(dlg, IDC_SSHCOMP_MOVEDOWN, uimsg, sizeof(uimsg));
2679 UTIL_get_lang_msg("DLG_SSHSETUP_COMP_DOWN", pvar, uimsg);
2680 SetDlgItemText(dlg, IDC_SSHCOMP_MOVEDOWN, pvar->ts->UIMsg);
2681
2682 GetDlgItemText(dlg, IDC_KNOWNHOSTS, uimsg, sizeof(uimsg));
2683 UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST", pvar, uimsg);
2684 SetDlgItemText(dlg, IDC_KNOWNHOSTS, pvar->ts->UIMsg);
2685 GetDlgItemText(dlg, IDC_CHOOSEREADWRITEFILE, uimsg, sizeof(uimsg));
2686 UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST_RW", pvar, uimsg);
2687 SetDlgItemText(dlg, IDC_CHOOSEREADWRITEFILE, pvar->ts->UIMsg);
2688 GetDlgItemText(dlg, IDC_CHOOSEREADONLYFILE, uimsg, sizeof(uimsg));
2689 UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST_RO", pvar, uimsg);
2690 SetDlgItemText(dlg, IDC_CHOOSEREADONLYFILE, pvar->ts->UIMsg);
2691 GetDlgItemText(dlg, IDC_HEARTBEATLABEL, uimsg, sizeof(uimsg));
2692 UTIL_get_lang_msg("DLG_SSHSETUP_HEARTBEAT", pvar, uimsg);
2693 SetDlgItemText(dlg, IDC_HEARTBEATLABEL, pvar->ts->UIMsg);
2694 GetDlgItemText(dlg, IDC_HEARTBEATLABEL2, uimsg, sizeof(uimsg));
2695 UTIL_get_lang_msg("DLG_SSHSETUP_HEARTBEAT_UNIT", pvar, uimsg);
2696 SetDlgItemText(dlg, IDC_HEARTBEATLABEL2, pvar->ts->UIMsg);
2697 GetDlgItemText(dlg, IDC_REMEMBERPASSWORD, uimsg, sizeof(uimsg));
2698 UTIL_get_lang_msg("DLG_SSHSETUP_PASSWORD", pvar, uimsg);
2699 SetDlgItemText(dlg, IDC_REMEMBERPASSWORD, pvar->ts->UIMsg);
2700 GetDlgItemText(dlg, IDC_FORWARDAGENT, uimsg, sizeof(uimsg));
2701 UTIL_get_lang_msg("DLG_SSHSETUP_FORWARDAGENT", pvar, uimsg);
2702 SetDlgItemText(dlg, IDC_FORWARDAGENT, pvar->ts->UIMsg);
2703 GetDlgItemText(dlg, IDC_FORWARDAGENTCONFIRM, uimsg, sizeof(uimsg));
2704 UTIL_get_lang_msg("DLG_SSHSETUP_FORWARDAGENTCONFIRM", pvar, uimsg);
2705 SetDlgItemText(dlg, IDC_FORWARDAGENTCONFIRM, pvar->ts->UIMsg);
2706 GetDlgItemText(dlg, IDC_VERIFYHOSTKEYDNS, uimsg, sizeof(uimsg));
2707 UTIL_get_lang_msg("DLG_SSHSETUP_VERIFYHOSTKEYDNS", pvar, uimsg);
2708 SetDlgItemText(dlg, IDC_VERIFYHOSTKEYDNS, pvar->ts->UIMsg);
2709 GetDlgItemText(dlg, IDC_NOTICEBANNER, uimsg, sizeof(uimsg));
2710 UTIL_get_lang_msg("DLG_SSHSETUP_NOTICE", pvar, uimsg);
2711 SetDlgItemText(dlg, IDC_NOTICEBANNER, pvar->ts->UIMsg);
2712 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
2713 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
2714 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
2715 GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
2716 UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
2717 SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
2718
2719 SendMessage(compressionControl, TBM_SETRANGE, TRUE, MAKELONG(0, 9));
2720 SendMessage(compressionControl, TBM_SETPOS, TRUE,
2721 pvar->settings.CompressionLevel);
2722
2723 // Cipher order
2724 normalize_cipher_order(pvar->settings.CipherOrder);
2725
2726 for (i = 0; pvar->settings.CipherOrder[i] != 0; i++) {
2727 int cipher = pvar->settings.CipherOrder[i] - '0';
2728 char FAR *name = get_cipher_name(cipher);
2729
2730 if (name != NULL) {
2731 SendMessage(cipherControl, LB_ADDSTRING, 0, (LPARAM) name);
2732 }
2733 }
2734
2735 SendMessage(cipherControl, LB_SETCURSEL, 0, 0);
2736 set_move_button_status(dlg, IDC_SSHCIPHERPREFS, IDC_SSHMOVECIPHERUP, IDC_SSHMOVECIPHERDOWN);
2737
2738 // KEX order
2739 normalize_kex_order(pvar->settings.KexOrder);
2740 for (i = 0; pvar->settings.KexOrder[i] != 0; i++) {
2741 int index = pvar->settings.KexOrder[i] - '0';
2742 char FAR *name = NULL;
2743
2744 if (index == 0) {
2745 UTIL_get_lang_msg("DLG_SSHSETUP_KEX_BORDER", pvar,
2746 "<KEXs below this line are disabled>");
2747 name = pvar->ts->UIMsg;
2748 } else {
2749 name = get_kex_algorithm_name(index);
2750 }
2751
2752 if (name != NULL) {
2753 SendMessage(kexControl, LB_ADDSTRING, 0, (LPARAM) name);
2754 }
2755 }
2756 SendMessage(kexControl, LB_SETCURSEL, 0, 0);
2757 set_move_button_status(dlg, IDC_SSHKEX_LIST, IDC_SSHKEX_MOVEUP, IDC_SSHKEX_MOVEDOWN);
2758
2759 // Host Key order
2760 normalize_host_key_order(pvar->settings.HostKeyOrder);
2761 for (i = 0; pvar->settings.HostKeyOrder[i] != 0; i++) {
2762 int index = pvar->settings.HostKeyOrder[i] - '0';
2763 char FAR *name = NULL;
2764
2765 if (index == 0) {
2766 UTIL_get_lang_msg("DLG_SSHSETUP_HOST_KEY_BORDER", pvar,
2767 "<Host Keys below this line are disabled>");
2768 name = pvar->ts->UIMsg;
2769 } else {
2770 name = get_ssh_keytype_name(index);
2771 }
2772
2773 if (name != NULL) {
2774 SendMessage(hostkeyControl, LB_ADDSTRING, 0, (LPARAM) name);
2775 }
2776 }
2777 SendMessage(hostkeyControl, LB_SETCURSEL, 0, 0);
2778 set_move_button_status(dlg, IDC_SSHHOST_KEY_LIST, IDC_SSHHOST_KEY_MOVEUP, IDC_SSHHOST_KEY_MOVEDOWN);
2779
2780 // MAC order
2781 normalize_mac_order(pvar->settings.MacOrder);
2782 for (i = 0; pvar->settings.MacOrder[i] != 0; i++) {
2783 int index = pvar->settings.MacOrder[i] - '0';
2784 char FAR *name = NULL;
2785
2786 if (index == 0) {
2787 UTIL_get_lang_msg("DLG_SSHSETUP_MAC_BORDER", pvar,
2788 "<MACs below this line are disabled>");
2789 name = pvar->ts->UIMsg;
2790 } else {
2791 name = get_ssh2_mac_name(index);
2792 }
2793
2794 if (name != NULL) {
2795 SendMessage(macControl, LB_ADDSTRING, 0, (LPARAM) name);
2796 }
2797 }
2798 SendMessage(macControl, LB_SETCURSEL, 0, 0);
2799 set_move_button_status(dlg, IDC_SSHMAC_LIST, IDC_SSHMAC_MOVEUP, IDC_SSHMAC_MOVEDOWN);
2800
2801 // Compression order
2802 normalize_comp_order(pvar->settings.CompOrder);
2803 for (i = 0; pvar->settings.CompOrder[i] != 0; i++) {
2804 int index = pvar->settings.CompOrder[i] - '0';
2805 char FAR *name = NULL;
2806
2807 if (index == 0) {
2808 UTIL_get_lang_msg("DLG_SSHSETUP_COMP_BORDER", pvar,
2809 "<Compressions below this line are disabled>");
2810 name = pvar->ts->UIMsg;
2811 } else {
2812 name = get_ssh2_comp_name(index);
2813 }
2814
2815 if (name != NULL) {
2816 SendMessage(compControl, LB_ADDSTRING, 0, (LPARAM) name);
2817 }
2818 }
2819 SendMessage(compControl, LB_SETCURSEL, 0, 0);
2820 set_move_button_status(dlg, IDC_SSHCOMP_LIST, IDC_SSHCOMP_MOVEUP, IDC_SSHCOMP_MOVEDOWN);
2821
2822 for (i = 0; (ch = pvar->settings.KnownHostsFiles[i]) != 0 && ch != ';';
2823 i++) {
2824 }
2825 if (ch != 0) {
2826 pvar->settings.KnownHostsFiles[i] = 0;
2827 SetDlgItemText(dlg, IDC_READWRITEFILENAME,
2828 pvar->settings.KnownHostsFiles);
2829 pvar->settings.KnownHostsFiles[i] = ch;
2830 SetDlgItemText(dlg, IDC_READONLYFILENAME,
2831 pvar->settings.KnownHostsFiles + i + 1);
2832 } else {
2833 SetDlgItemText(dlg, IDC_READWRITEFILENAME,
2834 pvar->settings.KnownHostsFiles);
2835 }
2836
2837 // SSH2 HeartBeat(keep-alive)������ (2005.2.22 yutaka)
2838 {
2839 char buf[10];
2840 _snprintf_s(buf, sizeof(buf), _TRUNCATE,
2841 "%d", pvar->settings.ssh_heartbeat_overtime);
2842 SetDlgItemText(dlg, IDC_HEARTBEAT_EDIT, buf);