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 3178 - (show annotations) (download) (as text)
Tue Dec 2 00:53:28 2008 UTC (15 years, 4 months ago) by doda
Original Path: ttssh2/trunk/ttxssh/ttxssh.c
File MIME type: text/x-csrc
File size: 121349 byte(s) 
・ssh:// URLをttsshで解釈するようにした。
・ssh1://, ssh2://, slogin://, slogin1://, slogin2:// URLに対応した。
  数字付きURLは、sshのバージョン指定版。
・ユーザ名,パスワードを含むURL(ssh://user:pass@host/)に対応した。
・インストーラで、slogin:// URLに関連付け出来るようにした。 (ssh:// URLと共通)

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