Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 3121 - (hide annotations) (download) (as text)
Tue Mar 4 12:10:05 2008 UTC (16 years, 1 month ago) by yutakapon
Original Path: ttssh2/trunk/ttxssh/ttxssh.c
File MIME type: text/x-csrc
File size: 117103 byte(s) 
リーク時のブロック番号を元にブレークを仕掛ける
1 yutakakn 2728 /*
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     /* Teraterm extension mechanism
30     Robert O'Callahan (roc+tt@cs.cmu.edu)
31    
32     Teraterm by Takashi Teranishi (teranishi@rikaxp.riken.go.jp)
33     */
34    
35     #include "ttxssh.h"
36     #include "fwdui.h"
37     #include "util.h"
38 yutakakn 2748 #include "ssh.h"
39 maya 2965 #include "ttcommon.h"
40 yutakakn 2728
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 maya 2980 #ifndef NO_INET6
53 yutakakn 2728 #include <winsock2.h>
54     static char FAR *ProtocolFamilyList[] = { "UNSPEC", "IPv6", "IPv4", NULL };
55     #else
56     #include <winsock.h>
57 maya 2980 #endif /* NO_INET6 */
58 yutakakn 2728
59 yutakakn 2816 #include <Lmcons.h>
60    
61     // include OpenSSL header file
62 yutakakn 2782 #include <openssl/opensslv.h>
63 yutakakn 2816 #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 yutakakn 2831 #include <openssl/md5.h>
71 yutakakn 2782
72 yutakakn 2820 // include ZLib header file
73     #include <zlib.h>
74    
75 yutakakn 2816 #include "buffer.h"
76     #include "cipher.h"
77    
78 yutakapon 3107 #include "sftp.h"
79 maya 2937
80 maya 2910 #define MATCH_STR(s, o) strncmp((s), (o), NUM_ELEM(o) - 1)
81 maya 2915 #define MATCH_STR_I(s, o) _strnicmp((s), (o), NUM_ELEM(o) - 1)
82 yutakakn 2728
83     /* This extension implements SSH, so we choose a load order in the
84     "protocols" range. */
85     #define ORDER 2500
86    
87 maya 2896 static HICON SecureLargeIcon = NULL;
88     static HICON SecureSmallIcon = NULL;
89 yutakakn 2728
90 maya 2943 static HFONT DlgHostFont;
91 maya 2937 static HFONT DlgAboutFont;
92 maya 2943 static HFONT DlgSetupFont;
93     static HFONT DlgKeygenFont;
94 maya 2937
95 yutakakn 2728 static TInstVar FAR *pvar;
96    
97     /* WIN32 allows multiple instances of a DLL */
98     static TInstVar InstVar;
99     #define GET_VAR()
100    
101     /*
102     This code makes lots of assumptions about the order in which Teraterm
103     does things, and how. A key assumption is that the Notification window
104     passed into WSAAsyncSelect is the main terminal window. We also assume
105     that the socket used in the first WSAconnect is the main session socket.
106     */
107    
108     static void init_TTSSH(PTInstVar pvar)
109     {
110     pvar->socket = INVALID_SOCKET;
111     pvar->OldLargeIcon = NULL;
112     pvar->OldSmallIcon = NULL;
113     pvar->NotificationWindow = NULL;
114     pvar->hostdlg_activated = FALSE;
115     pvar->socket = INVALID_SOCKET;
116     pvar->NotificationWindow = NULL;
117     pvar->protocol_major = 0;
118     pvar->protocol_minor = 0;
119    
120     PKT_init(pvar);
121     SSH_init(pvar);
122     CRYPT_init(pvar);
123     AUTH_init(pvar);
124     HOSTS_init(pvar);
125     FWD_init(pvar);
126     FWDUI_init(pvar);
127 yutakakn 2748
128     ssh_heartbeat_lock_initialize();
129 yutakakn 2728 }
130    
131     static void uninit_TTSSH(PTInstVar pvar)
132     {
133 yutakakn 2766 halt_ssh_heartbeat_thread(pvar);
134    
135 yutakakn 2809 ssh2_channel_free();
136    
137 yutakakn 2728 SSH_end(pvar);
138     PKT_end(pvar);
139     AUTH_end(pvar);
140     CRYPT_end(pvar);
141     HOSTS_end(pvar);
142     FWD_end(pvar);
143     FWDUI_end(pvar);
144    
145     if (pvar->OldLargeIcon != NULL) {
146     PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_BIG,
147 maya 3003 (LPARAM) pvar->OldLargeIcon);
148 yutakakn 2728 pvar->OldLargeIcon = NULL;
149     }
150     if (pvar->OldSmallIcon != NULL) {
151     PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_SMALL,
152 maya 3003 (LPARAM) pvar->OldSmallIcon);
153 yutakakn 2728 pvar->OldSmallIcon = NULL;
154     }
155 yutakakn 2766
156     ssh_heartbeat_lock_finalize();
157 yutakakn 2728 }
158    
159     static void PASCAL FAR TTXInit(PTTSet ts, PComVar cv)
160     {
161     pvar->settings = *pvar->ts_SSH;
162     pvar->ts = ts;
163     pvar->cv = cv;
164     pvar->fatal_error = FALSE;
165     pvar->showing_err = FALSE;
166     pvar->err_msg = NULL;
167    
168     init_TTSSH(pvar);
169     }
170    
171     static void normalize_cipher_order(char FAR * buf)
172     {
173     char ciphers_listed[SSH_CIPHER_MAX + 1];
174     char ciphers_allowed[SSH_CIPHER_MAX + 1];
175     int i, j;
176    
177     /* SSH_CIPHER_NONE means that all ciphers below that one are disabled.
178     We *never* allow no encryption. */
179     #if 0
180     static char default_ciphers[] = {
181     SSH_CIPHER_3DES,
182     SSH_CIPHER_NONE,
183     SSH_CIPHER_DES, SSH_CIPHER_BLOWFISH
184     };
185     #else
186     // for SSH2(yutaka)
187     static char default_ciphers[] = {
188 maya 3045 SSH2_CIPHER_AES128,
189     SSH2_CIPHER_3DES_CBC,
190     SSH2_CIPHER_BLOWFISH,
191     SSH2_CIPHER_AES192,
192     SSH2_CIPHER_AES256,
193 yutakakn 2728 SSH_CIPHER_3DES,
194     SSH_CIPHER_NONE,
195     SSH_CIPHER_DES, SSH_CIPHER_BLOWFISH
196     };
197     #endif
198    
199     memset(ciphers_listed, 0, sizeof(ciphers_listed));
200    
201     memset(ciphers_allowed, 0, sizeof(ciphers_allowed));
202     for (i = 0; i < NUM_ELEM(default_ciphers); i++) {
203     ciphers_allowed[default_ciphers[i]] = 1;
204     }
205    
206     for (i = 0; buf[i] != 0; i++) {
207     int cipher_num = buf[i] - '0';
208    
209     if (cipher_num < 0 || cipher_num > SSH_CIPHER_MAX
210     || !ciphers_allowed[cipher_num]
211     || ciphers_listed[cipher_num]) {
212     memmove(buf + i, buf + i + 1, strlen(buf + i + 1) + 1);
213     i--;
214     } else {
215     ciphers_listed[cipher_num] = 1;
216     }
217     }
218    
219     for (j = 0; j < NUM_ELEM(default_ciphers); j++) {
220     int cipher_num = default_ciphers[j];
221    
222     if (!ciphers_listed[cipher_num]) {
223     buf[i] = cipher_num + '0';
224     i++;
225     }
226     }
227    
228     buf[i] = 0;
229     }
230    
231     /* Remove local settings from the shared memory block. */
232     static void clear_local_settings(PTInstVar pvar)
233     {
234     pvar->ts_SSH->TryDefaultAuth = FALSE;
235     }
236    
237     static BOOL read_BOOL_option(PCHAR fileName, char FAR * keyName, BOOL def)
238     {
239     char buf[1024];
240    
241     buf[0] = 0;
242     GetPrivateProfileString("TTSSH", keyName, "", buf, sizeof(buf),
243 maya 3003 fileName);
244 yutakakn 2728 if (buf[0] == 0) {
245     return def;
246     } else {
247     return atoi(buf) != 0 ||
248 maya 3003 _stricmp(buf, "yes") == 0 ||
249     _stricmp(buf, "y") == 0;
250 yutakakn 2728 }
251     }
252    
253     static void read_string_option(PCHAR fileName, char FAR * keyName,
254 maya 3003 char FAR * def, char FAR * buf, int bufSize)
255 yutakakn 2728 {
256    
257     buf[0] = 0;
258     GetPrivateProfileString("TTSSH", keyName, def, buf, bufSize, fileName);
259     }
260    
261     static void read_ssh_options(PTInstVar pvar, PCHAR fileName)
262     {
263     char buf[1024];
264     TS_SSH FAR *settings = pvar->ts_SSH;
265    
266     #define READ_STD_STRING_OPTION(name) \
267 maya 3003 read_string_option(fileName, #name, "", settings->name, sizeof(settings->name))
268 yutakakn 2728
269     settings->Enabled = read_BOOL_option(fileName, "Enabled", FALSE);
270    
271     buf[0] = 0;
272     GetPrivateProfileString("TTSSH", "Compression", "", buf, sizeof(buf),
273 maya 3003 fileName);
274 yutakakn 2728 settings->CompressionLevel = atoi(buf);
275     if (settings->CompressionLevel < 0 || settings->CompressionLevel > 9) {
276     settings->CompressionLevel = 0;
277     }
278    
279     READ_STD_STRING_OPTION(DefaultUserName);
280     READ_STD_STRING_OPTION(DefaultForwarding);
281     READ_STD_STRING_OPTION(DefaultRhostsLocalUserName);
282     READ_STD_STRING_OPTION(DefaultRhostsHostPrivateKeyFile);
283     READ_STD_STRING_OPTION(DefaultRSAPrivateKeyFile);
284    
285     READ_STD_STRING_OPTION(CipherOrder);
286     normalize_cipher_order(settings->CipherOrder);
287    
288     read_string_option(fileName, "KnownHostsFiles", "ssh_known_hosts",
289 maya 3003 settings->KnownHostsFiles,
290     sizeof(settings->KnownHostsFiles));
291 yutakakn 2728
292     buf[0] = 0;
293     GetPrivateProfileString("TTSSH", "DefaultAuthMethod", "", buf,
294 maya 3003 sizeof(buf), fileName);
295 yutakakn 2728 settings->DefaultAuthMethod = atoi(buf);
296     if (settings->DefaultAuthMethod != SSH_AUTH_PASSWORD
297 maya 3003 && settings->DefaultAuthMethod != SSH_AUTH_RSA
298     && settings->DefaultAuthMethod != SSH_AUTH_TIS // add (2005.3.12 yutaka)
299 maya 3108 && settings->DefaultAuthMethod != SSH_AUTH_RHOSTS
300     && settings->DefaultAuthMethod != SSH_AUTH_PAGEANT) {
301 yutakakn 2728 /* this default can never be SSH_AUTH_RHOSTS_RSA because that is not a
302     selection in the dialog box; SSH_AUTH_RHOSTS_RSA is automatically chosen
303     when the dialog box has rhosts selected and an host private key file
304     is supplied. */
305     settings->DefaultAuthMethod = SSH_AUTH_PASSWORD;
306     }
307    
308     buf[0] = 0;
309     GetPrivateProfileString("TTSSH", "LogLevel", "", buf, sizeof(buf),
310 maya 3003 fileName);
311 yutakakn 2728 settings->LogLevel = atoi(buf);
312    
313     buf[0] = 0;
314     GetPrivateProfileString("TTSSH", "WriteBufferSize", "", buf,
315 maya 3003 sizeof(buf), fileName);
316 yutakakn 2728 settings->WriteBufferSize = atoi(buf);
317     if (settings->WriteBufferSize <= 0) {
318     settings->WriteBufferSize = 2 * 1024 * 1024;
319     }
320    
321     settings->LocalForwardingIdentityCheck =
322     read_BOOL_option(fileName, "LocalForwardingIdentityCheck", TRUE);
323    
324     // SSH protocol version (2004.10.11 yutaka)
325 yutakakn 2738 // default is SSH2 (2004.11.30 yutaka)
326     settings->ssh_protocol_version = GetPrivateProfileInt("TTSSH", "ProtocolVersion", 2, fileName);
327 yutakakn 2728
328 yutakakn 2748 // SSH heartbeat time(second) (2004.12.11 yutaka)
329     settings->ssh_heartbeat_overtime = GetPrivateProfileInt("TTSSH", "HeartBeat", 60, fileName);
330    
331 yutakakn 2891 // �p�X���[�h�F�����������J���F�����g���p�X���[�h����������������������������������
332     // �\���B(2006.8.5 yutaka)
333     settings->remember_password = GetPrivateProfileInt("TTSSH", "RememberPassword", 1, fileName);
334    
335 maya 3015 // �������F���_�C�A���O���T�|�[�g�������������\�b�h���`�F�b�N���A
336     // ���������\�b�h���O���C�A�E�g���� (2007.9.24 maya)
337 maya 3035 settings->CheckAuthListFirst = read_BOOL_option(fileName, "CheckAuthListFirst", FALSE);
338 maya 3015
339 yutakakn 2728 clear_local_settings(pvar);
340     }
341    
342     static void write_ssh_options(PTInstVar pvar, PCHAR fileName,
343 maya 2909 TS_SSH FAR * settings, BOOL copy_forward)
344 yutakakn 2728 {
345     char buf[1024];
346    
347     WritePrivateProfileString("TTSSH", "Enabled",
348 maya 3003 settings->Enabled ? "1" : "0", fileName);
349 yutakakn 2728
350     _itoa(settings->CompressionLevel, buf, 10);
351     WritePrivateProfileString("TTSSH", "Compression", buf, fileName);
352    
353     WritePrivateProfileString("TTSSH", "DefaultUserName",
354 maya 3003 settings->DefaultUserName, fileName);
355 yutakakn 2728
356 maya 2909 if (copy_forward) {
357     WritePrivateProfileString("TTSSH", "DefaultForwarding",
358 maya 3003 settings->DefaultForwarding, fileName);
359 maya 2909 }
360 yutakakn 2728
361     WritePrivateProfileString("TTSSH", "CipherOrder",
362 maya 3003 settings->CipherOrder, fileName);
363 yutakakn 2728
364     WritePrivateProfileString("TTSSH", "KnownHostsFiles",
365 maya 3003 settings->KnownHostsFiles, fileName);
366 yutakakn 2728
367     WritePrivateProfileString("TTSSH", "DefaultRhostsLocalUserName",
368 maya 3003 settings->DefaultRhostsLocalUserName,
369     fileName);
370 yutakakn 2728
371     WritePrivateProfileString("TTSSH", "DefaultRhostsHostPrivateKeyFile",
372 maya 3003 settings->DefaultRhostsHostPrivateKeyFile,
373     fileName);
374 yutakakn 2728
375     WritePrivateProfileString("TTSSH", "DefaultRSAPrivateKeyFile",
376 maya 3003 settings->DefaultRSAPrivateKeyFile,
377     fileName);
378 yutakakn 2728
379     _itoa(settings->DefaultAuthMethod, buf, 10);
380     WritePrivateProfileString("TTSSH", "DefaultAuthMethod", buf, fileName);
381    
382     _itoa(settings->LogLevel, buf, 10);
383     WritePrivateProfileString("TTSSH", "LogLevel", buf, fileName);
384    
385     _itoa(settings->WriteBufferSize, buf, 10);
386     WritePrivateProfileString("TTSSH", "WriteBufferSize", buf, fileName);
387    
388     WritePrivateProfileString("TTSSH", "LocalForwardingIdentityCheck",
389 maya 3003 settings->LocalForwardingIdentityCheck ? "1" : "0",
390     fileName);
391 yutakakn 2728
392     // SSH protocol version (2004.10.11 yutaka)
393     WritePrivateProfileString("TTSSH", "ProtocolVersion",
394 maya 3003 settings->ssh_protocol_version==2 ? "2" : "1",
395     fileName);
396 yutakakn 2728
397 yutakakn 2748 // SSH heartbeat time(second) (2004.12.11 yutaka)
398 maya 2992 _snprintf_s(buf, sizeof(buf), _TRUNCATE,
399 maya 3003 "%d", settings->ssh_heartbeat_overtime);
400 yutakakn 2748 WritePrivateProfileString("TTSSH", "HeartBeat", buf, fileName);
401    
402 yutakakn 2891 // Remember password (2006.8.5 yutaka)
403     WritePrivateProfileString("TTSSH", "RememberPassword",
404 maya 3003 settings->remember_password ? "1" : "0",
405     fileName);
406 maya 3015
407     // �������F���_�C�A���O���T�|�[�g�������������\�b�h���`�F�b�N���A
408     // ���������\�b�h���O���C�A�E�g���� (2007.9.24 maya)
409     WritePrivateProfileString("TTSSH", "CheckAuthListFirst",
410     settings->CheckAuthListFirst ? "1" : "0", fileName);
411 yutakakn 2728 }
412    
413 yutakakn 2748
414 yutakakn 2728 /* find free port in all protocol family */
415     static unsigned short find_local_port(PTInstVar pvar)
416     {
417     int tries;
418 maya 2980 #ifndef NO_INET6
419 yutakakn 2728 SOCKET connecter;
420     struct addrinfo hints;
421     struct addrinfo FAR *res;
422     struct addrinfo FAR *res0;
423     unsigned short port;
424     char pname[NI_MAXHOST];
425 maya 2980 #endif /* NO_INET6 */
426 yutakakn 2728
427     if (pvar->session_settings.DefaultAuthMethod != SSH_AUTH_RHOSTS) {
428     return 0;
429     }
430    
431     /* The random numbers here are only used to try to get fresh
432     ports across runs (dangling ports can cause bind errors
433     if we're unlucky). They do not need to be (and are not)
434     cryptographically strong.
435     */
436     srand((unsigned) GetTickCount());
437    
438 maya 2980 #ifndef NO_INET6
439 yutakakn 2728 for (tries = 20; tries > 0; tries--) {
440     memset(&hints, 0, sizeof(hints));
441     hints.ai_family = pvar->ts->ProtocolFamily;
442     hints.ai_flags = AI_PASSIVE;
443     hints.ai_socktype = SOCK_STREAM;
444     port = (unsigned) rand() % 512 + 512;
445 maya 2992 _snprintf_s(pname, sizeof(pname), _TRUNCATE, "%d", (int) port);
446 yutakakn 2728 if (getaddrinfo(NULL, pname, &hints, &res0)) {
447     return 0;
448     /* NOT REACHED */
449     }
450    
451     for (res = res0; res; res = res->ai_next) {
452     if (res->ai_family == AF_INET || res->ai_family == AF_INET6)
453     continue;
454    
455     connecter =
456     socket(res->ai_family, res->ai_socktype, res->ai_protocol);
457     if (connecter == INVALID_SOCKET) {
458     freeaddrinfo(res0);
459     return 0;
460     }
461    
462     if (bind(connecter, res->ai_addr, res->ai_addrlen) !=
463 maya 3003 SOCKET_ERROR) {
464 yutakakn 2728 return port;
465     freeaddrinfo(res0);
466     closesocket(connecter);
467     } else if (WSAGetLastError() != WSAEADDRINUSE) {
468     closesocket(connecter);
469     freeaddrinfo(res0);
470     return 0;
471     }
472    
473     closesocket(connecter);
474     }
475     freeaddrinfo(res0);
476     }
477    
478     return 0;
479     #else
480     for (tries = 20; tries > 0; tries--) {
481     SOCKET connecter = socket(AF_INET, SOCK_STREAM, 0);
482     struct sockaddr_in connecter_addr;
483    
484     connecter_addr.sin_family = AF_INET;
485     connecter_addr.sin_port = (unsigned) rand() % 512 + 512;
486     connecter_addr.sin_addr.s_addr = htonl(INADDR_ANY);
487    
488     if (connecter == INVALID_SOCKET) {
489     return 0;
490     }
491    
492     if (bind
493 maya 3003 (connecter, (struct sockaddr FAR *) &connecter_addr,
494     sizeof(connecter_addr)) != SOCKET_ERROR) {
495     closesocket(connecter);
496 yutakakn 2728 return connecter_addr.sin_port;
497     } else if (WSAGetLastError() != WSAEADDRINUSE) {
498     closesocket(connecter);
499     return 0;
500     }
501    
502     closesocket(connecter);
503     }
504    
505     return 0;
506 maya 2980 #endif /* NO_INET6 */
507 yutakakn 2728 }
508    
509     static int PASCAL FAR TTXconnect(SOCKET s,
510 maya 3003 const struct sockaddr FAR * name,
511     int namelen)
512 yutakakn 2728 {
513     GET_VAR();
514    
515 maya 2980 #ifndef NO_INET6
516 yutakakn 2728 if (pvar->socket == INVALID_SOCKET) {
517     struct sockaddr_storage ss;
518     int len;
519    
520     pvar->socket = s;
521    
522     memset(&ss, 0, sizeof(ss));
523     switch (pvar->ts->ProtocolFamily) {
524     case AF_INET:
525     len = sizeof(struct sockaddr_in);
526     ((struct sockaddr_in FAR *) &ss)->sin_family = AF_INET;
527     ((struct sockaddr_in FAR *) &ss)->sin_addr.s_addr = INADDR_ANY;
528     ((struct sockaddr_in FAR *) &ss)->sin_port =
529     htons(find_local_port(pvar));
530     break;
531     case AF_INET6:
532     len = sizeof(struct sockaddr_in6);
533     ((struct sockaddr_in6 FAR *) &ss)->sin6_family = AF_INET6;
534     #if 0 /* symbol "in6addr_any" is not included in wsock32.lib */
535     /* if wsock32.lib will be linked, we can't refer "in6addr_any" */
536     ((struct sockaddr_in6 FAR *) &ss)->sin6_addr = in6addr_any;
537 maya 3003 #else
538 yutakakn 2728 memset(&((struct sockaddr_in6 FAR *) &ss)->sin6_addr, 0,
539 maya 3003 sizeof(struct in_addr6));
540 yutakakn 2728 #endif /* 0 */
541     ((struct sockaddr_in6 FAR *) &ss)->sin6_port =
542     htons(find_local_port(pvar));
543     break;
544     default:
545     /* NOT REACHED */
546     break;
547     }
548    
549     bind(s, (struct sockaddr FAR *) &ss, len);
550     }
551     #else
552     if (pvar->socket == INVALID_SOCKET) {
553     struct sockaddr_in addr;
554    
555     pvar->socket = s;
556    
557     addr.sin_family = AF_INET;
558     addr.sin_port = htons(find_local_port(pvar));
559     addr.sin_addr.s_addr = INADDR_ANY;
560     memset(addr.sin_zero, 0, sizeof(addr.sin_zero));
561    
562     bind(s, (struct sockaddr FAR *) &addr, sizeof(addr));
563     }
564 maya 2980 #endif /* NO_INET6 */
565 yutakakn 2728
566     return (pvar->Pconnect) (s, name, namelen);
567     }
568    
569     static int PASCAL FAR TTXWSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg,
570 maya 3003 long lEvent)
571 yutakakn 2728 {
572     GET_VAR();
573    
574     if (s == pvar->socket) {
575     pvar->notification_events = lEvent;
576     pvar->notification_msg = wMsg;
577    
578     if (pvar->NotificationWindow == NULL) {
579     pvar->NotificationWindow = hWnd;
580     AUTH_advance_to_next_cred(pvar);
581     }
582     }
583    
584     return (pvar->PWSAAsyncSelect) (s, hWnd, wMsg, lEvent);
585     }
586    
587     static int PASCAL FAR TTXrecv(SOCKET s, char FAR * buf, int len, int flags)
588     {
589     GET_VAR();
590    
591     if (s == pvar->socket) {
592 yutakakn 2748 int ret;
593    
594     ssh_heartbeat_lock();
595     ret = PKT_recv(pvar, buf, len);
596     ssh_heartbeat_unlock();
597     return (ret);
598    
599 yutakakn 2728 } else {
600     return (pvar->Precv) (s, buf, len, flags);
601     }
602     }
603    
604     static int PASCAL FAR TTXsend(SOCKET s, char const FAR * buf, int len,
605 maya 3003 int flags)
606 yutakakn 2728 {
607     GET_VAR();
608    
609     if (s == pvar->socket) {
610 yutakakn 2748 ssh_heartbeat_lock();
611 yutakakn 2728 SSH_send(pvar, buf, len);
612 yutakakn 2748 ssh_heartbeat_unlock();
613 yutakakn 2728 return len;
614     } else {
615     return (pvar->Psend) (s, buf, len, flags);
616     }
617     }
618    
619     void notify_established_secure_connection(PTInstVar pvar)
620     {
621 maya 2897 // LoadIcon �������� LoadImage ���g�����������A
622     // 16x16 ���A�C�R���������I�������������������� (2006.8.9 maya)
623 maya 2896 if (SecureLargeIcon == NULL) {
624     SecureLargeIcon = LoadImage(hInst, MAKEINTRESOURCE(IDI_SECURETT),
625 maya 3003 IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
626 yutakakn 2728 }
627 maya 2896 if (SecureSmallIcon == NULL) {
628     SecureSmallIcon = LoadImage(hInst, MAKEINTRESOURCE(IDI_SECURETT),
629 maya 3003 IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
630 maya 2896 }
631 yutakakn 2728
632 maya 2896 if (SecureLargeIcon != NULL && SecureSmallIcon != NULL) {
633 maya 2897 // �������A�C�R���� WNDCLASS ���Z�b�g�����������������o���������� (2006.8.10 maya)
634     pvar->OldLargeIcon =
635     (HICON) GetClassLong(pvar->NotificationWindow, GCL_HICON);
636 yutakakn 2728 pvar->OldSmallIcon =
637     (HICON) SendMessage(pvar->NotificationWindow, WM_GETICON,
638 maya 3003 ICON_SMALL, 0);
639 maya 2897
640 yutakakn 2728 PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_BIG,
641 maya 3003 (LPARAM) SecureLargeIcon);
642 yutakakn 2728 PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_SMALL,
643 maya 3003 (LPARAM) SecureSmallIcon);
644 yutakakn 2728 }
645    
646     notify_verbose_message(pvar, "Entering secure mode",
647 maya 3003 LOG_LEVEL_VERBOSE);
648 yutakakn 2728 }
649    
650     void notify_closed_connection(PTInstVar pvar)
651     {
652 yutakakn 2766 SSH_notify_disconnecting(pvar, NULL);
653     AUTH_notify_disconnecting(pvar);
654     HOSTS_notify_disconnecting(pvar);
655    
656 yutakakn 2728 PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
657 maya 3003 pvar->socket, MAKELPARAM(FD_CLOSE, 0));
658 yutakakn 2728
659     }
660    
661     static void add_err_msg(PTInstVar pvar, char FAR * msg)
662     {
663     if (pvar->err_msg != NULL) {
664 maya 2992 int buf_len = strlen(pvar->err_msg) + 3 + strlen(msg);
665     char FAR *buf = (char FAR *) malloc(buf_len);
666 yutakakn 2728
667 maya 2992 strncpy_s(buf, buf_len, pvar->err_msg, _TRUNCATE);
668     strncat_s(buf, buf_len, "\n\n", _TRUNCATE);
669     strncat_s(buf, buf_len, msg, _TRUNCATE);
670 yutakakn 2728 free(pvar->err_msg);
671     pvar->err_msg = buf;
672     } else {
673     pvar->err_msg = _strdup(msg);
674     }
675     }
676    
677     void notify_nonfatal_error(PTInstVar pvar, char FAR * msg)
678     {
679     if (!pvar->showing_err) {
680 yutakakn 2868 // �������������������m���E�B���h�E�����������A�f�X�N�g�b�v���I�[�i�[������
681     // ���b�Z�[�W�{�b�N�X���o���������B(2006.6.11 yutaka)
682     if (pvar->NotificationWindow == NULL) {
683 maya 2994 UTIL_get_lang_msg("MSG_ERROR_NONFAITAL", pvar,
684 maya 3003 "Tera Term: not fatal error");
685 maya 2937 MessageBox(NULL, msg, pvar->ts->UIMsg, MB_OK|MB_ICONINFORMATION);
686 yutakakn 2868 msg[0] = '\0';
687    
688     } else {
689     PostMessage(pvar->NotificationWindow, WM_COMMAND,
690 maya 3003 ID_SSHASYNCMESSAGEBOX, 0);
691 yutakakn 2868 }
692 yutakakn 2728 }
693     if (msg[0] != 0) {
694     notify_verbose_message(pvar, msg, LOG_LEVEL_ERROR);
695     add_err_msg(pvar, msg);
696     }
697     }
698    
699     void notify_fatal_error(PTInstVar pvar, char FAR * msg)
700     {
701     if (msg[0] != 0) {
702     notify_verbose_message(pvar, msg, LOG_LEVEL_FATAL);
703     add_err_msg(pvar, msg);
704     }
705    
706     if (!pvar->fatal_error) {
707     pvar->fatal_error = TRUE;
708    
709     SSH_notify_disconnecting(pvar, msg);
710     AUTH_notify_disconnecting(pvar);
711     HOSTS_notify_disconnecting(pvar);
712    
713     PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
714 maya 3003 pvar->socket, MAKELPARAM(FD_CLOSE,
715     (pvar->PWSAGetLastError) ()));
716 yutakakn 2728 }
717     }
718    
719     void notify_verbose_message(PTInstVar pvar, char FAR * msg, int level)
720     {
721     if (level <= pvar->session_settings.LogLevel) {
722     char buf[1024];
723     int file;
724    
725     get_teraterm_dir_relative_name(buf, NUM_ELEM(buf), "TTSSH.LOG");
726     file = _open(buf, _O_RDWR | _O_APPEND | _O_CREAT | _O_TEXT,
727 maya 3003 _S_IREAD | _S_IWRITE);
728 yutakakn 2728
729     if (file >= 0) {
730     _write(file, msg, strlen(msg));
731     _write(file, "\n", 1);
732     _close(file);
733     }
734     }
735     }
736    
737     static void PASCAL FAR TTXOpenTCP(TTXSockHooks FAR * hooks)
738     {
739     GET_VAR();
740    
741     if (pvar->settings.Enabled) {
742 yutakakn 2805 char buf[1024] = "\n---------------------------------------------------------------------\nInitiating SSH session at ";
743 yutakakn 2728 struct tm FAR *newtime;
744     time_t long_time;
745    
746 maya 2970 // TCPLocalEcho/TCPCRSend ������������ (maya 2007.4.25)
747     pvar->ts->DisableTCPEchoCR = TRUE;
748    
749 yutakakn 2728 pvar->session_settings = pvar->settings;
750    
751     time(&long_time);
752     newtime = localtime(&long_time);
753 maya 2992 strncat_s(buf, sizeof(buf), asctime(newtime), _TRUNCATE);
754 yutakakn 2728 notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
755    
756     FWDUI_load_settings(pvar);
757    
758     pvar->cv->TelAutoDetect = FALSE;
759     /* This next line should not be needed because Teraterm's
760     CommLib should find ts->Telnet == 0 ... but we'll do this
761     just to be on the safe side. */
762     pvar->cv->TelFlag = FALSE;
763    
764     pvar->Precv = *hooks->Precv;
765     pvar->Psend = *hooks->Psend;
766     pvar->PWSAAsyncSelect = *hooks->PWSAAsyncSelect;
767     pvar->Pconnect = *hooks->Pconnect;
768     pvar->PWSAGetLastError = *hooks->PWSAGetLastError;
769    
770     *hooks->Precv = TTXrecv;
771     *hooks->Psend = TTXsend;
772     *hooks->PWSAAsyncSelect = TTXWSAAsyncSelect;
773     *hooks->Pconnect = TTXconnect;
774    
775     SSH_open(pvar);
776     HOSTS_open(pvar);
777     FWDUI_open(pvar);
778 yutakakn 2875
779     // ������ myproposal �����f���������A�������O�����������B (2006.6.26 maya)
780     SSH2_update_cipher_myproposal(pvar);
781     SSH2_update_compression_myproposal(pvar);
782 yutakakn 2728 }
783     }
784    
785     static void PASCAL FAR TTXCloseTCP(TTXSockHooks FAR * hooks)
786     {
787     GET_VAR();
788    
789     if (pvar->session_settings.Enabled) {
790     pvar->socket = INVALID_SOCKET;
791    
792     notify_verbose_message(pvar, "Terminating SSH session...",
793 maya 3003 LOG_LEVEL_VERBOSE);
794 yutakakn 2728
795     *hooks->Precv = pvar->Precv;
796     *hooks->Psend = pvar->Psend;
797     *hooks->PWSAAsyncSelect = pvar->PWSAAsyncSelect;
798     *hooks->Pconnect = pvar->Pconnect;
799     }
800    
801     uninit_TTSSH(pvar);
802     init_TTSSH(pvar);
803     }
804    
805     static void enable_dlg_items(HWND dlg, int from, int to, BOOL enabled)
806     {
807     for (; from <= to; from++) {
808     EnableWindow(GetDlgItem(dlg, from), enabled);
809     }
810     }
811    
812 maya 3010 // C-p/C-n/C-b/C-f/C-a/C-e ���T�|�[�g (2007.9.5 maya)
813 yutakapon 3022 // C-d/C-k ���T�|�[�g (2007.10.3 yutaka)
814 maya 3008 // �h���b�v�_�E���������G�f�B�b�g�R���g���[����
815     // �T�u�N���X�������������E�C���h�E�v���V�[�W��
816 yutakapon 3022 WNDPROC OrigHostnameEditProc; // Original window procedure
817     LRESULT CALLBACK HostnameEditProc(HWND dlg, UINT msg,
818 maya 3008 WPARAM wParam, LPARAM lParam)
819     {
820     HWND parent;
821 yutakapon 3022 int max, select, len;
822 yutakapon 3048 char *str, *orgstr;
823 maya 3008
824     switch (msg) {
825     // �L�[�����������������m����
826     case WM_KEYDOWN:
827     if (GetKeyState(VK_CONTROL) < 0) {
828     switch (wParam) {
829 maya 3010 case 0x50: // Ctrl+p ... up
830 maya 3008 parent = GetParent(dlg);
831 maya 3010 select = SendMessage(parent, CB_GETCURSEL, 0, 0);
832     if (select > 0) {
833     PostMessage(parent, CB_SETCURSEL, select - 1, 0);
834 maya 3008 }
835     return 0;
836 maya 3010 case 0x4e: // Ctrl+n ... down
837 maya 3008 parent = GetParent(dlg);
838 maya 3010 max = SendMessage(parent, CB_GETCOUNT, 0, 0);
839     select = SendMessage(parent, CB_GETCURSEL, 0, 0);
840     if (select < max - 1) {
841     PostMessage(parent, CB_SETCURSEL, select + 1, 0);
842 maya 3008 }
843     return 0;
844 maya 3010 case 0x42: // Ctrl+b ... left
845     SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
846     PostMessage(dlg, EM_SETSEL, select-1, select-1);
847     return 0;
848     case 0x46: // Ctrl+f ... right
849     SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
850     max = GetWindowTextLength(dlg) ;
851     PostMessage(dlg, EM_SETSEL, select+1, select+1);
852     return 0;
853     case 0x41: // Ctrl+a ... home
854 maya 3009 PostMessage(dlg, EM_SETSEL, 0, 0);
855     return 0;
856 maya 3010 case 0x45: // Ctrl+e ... end
857     max = GetWindowTextLength(dlg) ;
858     PostMessage(dlg, EM_SETSEL, max, max);
859 maya 3009 return 0;
860 yutakapon 3022
861     case 0x44: // Ctrl+d
862     case 0x4b: // Ctrl+k
863 yutakapon 3048 case 0x55: // Ctrl+u
864 yutakapon 3022 SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
865     max = GetWindowTextLength(dlg);
866     max++; // '\0'
867 yutakapon 3048 orgstr = str = malloc(max);
868 yutakapon 3022 if (str != NULL) {
869     len = GetWindowText(dlg, str, max);
870     if (select >= 0 && select < len) {
871     if (wParam == 0x44) { // �J�[�\���z����������������������
872     memmove(&str[select], &str[select + 1], len - select - 1);
873     str[len - 1] = '\0';
874    
875     } else if (wParam == 0x4b) { // �J�[�\�������s��������������
876     str[select] = '\0';
877 yutakapon 3048
878 yutakapon 3022 }
879 yutakapon 3048 }
880 yutakapon 3022
881 yutakapon 3048 if (wParam == 0x55) { // �J�[�\����������������������
882     if (select >= len) {
883     str[0] = '\0';
884     } else {
885     str = &str[select];
886     }
887     select = 0;
888 yutakapon 3022 }
889 yutakapon 3048
890     SetWindowText(dlg, str);
891     SendMessage(dlg, EM_SETSEL, select, select);
892     free(orgstr);
893 yutakapon 3022 return 0;
894     }
895     break;
896 maya 3008 }
897     }
898     break;
899    
900 maya 3010 // �����L�[��������������������������������������������
901 maya 3008 case WM_CHAR:
902     switch (wParam) {
903 maya 3009 case 0x01:
904 maya 3010 case 0x02:
905 yutakapon 3022 case 0x04:
906 maya 3009 case 0x05:
907 maya 3010 case 0x06:
908 yutakapon 3022 case 0x0b:
909 maya 3008 case 0x0e:
910     case 0x10:
911 yutakapon 3048 case 0x15:
912 maya 3008 return 0;
913     }
914     }
915    
916     return CallWindowProc(OrigHostnameEditProc, dlg, msg, wParam, lParam);
917     }
918    
919 yutakakn 2728 static BOOL CALLBACK TTXHostDlg(HWND dlg, UINT msg, WPARAM wParam,
920 maya 3003 LPARAM lParam)
921 yutakakn 2728 {
922     static char *ssh_version[] = {"SSH1", "SSH2", NULL};
923     PGetHNRec GetHNRec;
924 yutakapon 2996 char EntName[128];
925 yutakakn 2728 char TempHost[HostNameMaxLength + 1];
926     WORD i, j, w;
927 maya 3021 WORD ComPortTable[MAXCOMPORT];
928 yutakapon 2996 static char *ComPortDesc[MAXCOMPORT];
929 doda 2964 int comports;
930 yutakakn 2728 BOOL Ok;
931 maya 2943 LOGFONT logfont;
932     HFONT font;
933 maya 2994 char uimsg[MAX_UIMSG];
934 maya 3099 static HWND hwndHostname = NULL; // HOSTNAME dropdown
935     static HWND hwndHostnameEdit = NULL; // Edit control on HOSTNAME dropdown
936 yutakakn 2728
937     GET_VAR();
938    
939     switch (msg) {
940     case WM_INITDIALOG:
941     GetHNRec = (PGetHNRec) lParam;
942     SetWindowLong(dlg, DWL_USER, lParam);
943    
944 maya 2994 GetWindowText(dlg, uimsg, sizeof(uimsg));
945     UTIL_get_lang_msg("DLG_HOST_TITLE", pvar, uimsg);
946 maya 2937 SetWindowText(dlg, pvar->ts->UIMsg);
947 maya 2994 GetDlgItemText(dlg, IDC_HOSTNAMELABEL, uimsg, sizeof(uimsg));
948 maya 3114 UTIL_get_lang_msg("DLG_HOST_TCPIPHOST", pvar, uimsg);
949 maya 2937 SetDlgItemText(dlg, IDC_HOSTNAMELABEL, pvar->ts->UIMsg);
950 maya 2994 GetDlgItemText(dlg, IDC_HISTORY, uimsg, sizeof(uimsg));
951 maya 3114 UTIL_get_lang_msg("DLG_HOST_TCPIPHISTORY", pvar, uimsg);
952 maya 2937 SetDlgItemText(dlg, IDC_HISTORY, pvar->ts->UIMsg);
953 maya 2994 GetDlgItemText(dlg, IDC_SERVICELABEL, uimsg, sizeof(uimsg));
954 maya 3114 UTIL_get_lang_msg("DLG_HOST_TCPIPSERVICE", pvar, uimsg);
955 maya 2937 SetDlgItemText(dlg, IDC_SERVICELABEL, pvar->ts->UIMsg);
956 maya 2994 GetDlgItemText(dlg, IDC_HOSTOTHER, uimsg, sizeof(uimsg));
957 maya 3114 UTIL_get_lang_msg("DLG_HOST_TCPIPOTHER", pvar, uimsg);
958 maya 2937 SetDlgItemText(dlg, IDC_HOSTOTHER, pvar->ts->UIMsg);
959 maya 2994 GetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, uimsg, sizeof(uimsg));
960 maya 3114 UTIL_get_lang_msg("DLG_HOST_TCPIPPORT", pvar, uimsg);
961 maya 2937 SetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, pvar->ts->UIMsg);
962 maya 2994 GetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, uimsg, sizeof(uimsg));
963 maya 3114 UTIL_get_lang_msg("DLG_HOST_TCPIPSSHVERSION", pvar, uimsg);
964 maya 2937 SetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, pvar->ts->UIMsg);
965 maya 2994 GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, uimsg, sizeof(uimsg));
966 maya 3114 UTIL_get_lang_msg("DLG_HOST_TCPIPPROTOCOL", pvar, uimsg);
967 maya 2937 SetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, pvar->ts->UIMsg);
968 maya 2994 GetDlgItemText(dlg, IDC_HOSTSERIAL, uimsg, sizeof(uimsg));
969     UTIL_get_lang_msg("DLG_HOST_SERIAL", pvar, uimsg);
970 maya 2937 SetDlgItemText(dlg, IDC_HOSTSERIAL, pvar->ts->UIMsg);
971 maya 2994 GetDlgItemText(dlg, IDC_HOSTCOMLABEL, uimsg, sizeof(uimsg));
972 maya 3114 UTIL_get_lang_msg("DLG_HOST_SERIALPORT", pvar, uimsg);
973 maya 2937 SetDlgItemText(dlg, IDC_HOSTCOMLABEL, pvar->ts->UIMsg);
974 maya 2994 GetDlgItemText(dlg, IDC_HOSTHELP, uimsg, sizeof(uimsg));
975     UTIL_get_lang_msg("DLG_HOST_HELP", pvar, uimsg);
976 maya 2937 SetDlgItemText(dlg, IDC_HOSTHELP, pvar->ts->UIMsg);
977 maya 2994 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
978     UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
979 maya 2937 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
980 maya 2994 GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
981     UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
982 maya 2937 SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
983    
984 yutakakn 2846 // �z�X�g�q�X�g�����`�F�b�N�{�b�N�X������ (2005.10.21 yutaka)
985     if (pvar->ts->HistoryList > 0) {
986     SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_CHECKED, 0);
987     } else {
988     SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_UNCHECKED, 0);
989     }
990    
991 yutakakn 2728 if (GetHNRec->PortType == IdFile)
992     GetHNRec->PortType = IdTCPIP;
993    
994 maya 2992 strncpy_s(EntName, sizeof(EntName), "Host", _TRUNCATE);
995 yutakakn 2728
996     i = 1;
997     do {
998 maya 2992 _snprintf_s(&EntName[4], sizeof(EntName)-4, _TRUNCATE, "%d", i);
999 yutakakn 2728 GetPrivateProfileString("Hosts", EntName, "",
1000 maya 3003 TempHost, sizeof(TempHost),
1001     GetHNRec->SetupFN);
1002 yutakakn 2728 if (strlen(TempHost) > 0)
1003     SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_ADDSTRING,
1004 maya 3003 0, (LPARAM) TempHost);
1005 yutakakn 2728 i++;
1006 maya 3005 } while ((i <= MAXHOSTLIST) && (strlen(TempHost) > 0));
1007 yutakakn 2728
1008     SendDlgItemMessage(dlg, IDC_HOSTNAME, EM_LIMITTEXT,
1009 maya 3003 HostNameMaxLength - 1, 0);
1010 yutakakn 2728
1011     SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_SETCURSEL, 0, 0);
1012    
1013 maya 3008 // C-n/C-p ���������T�u�N���X�� (2007.9.4 maya)
1014     hwndHostname = GetDlgItem(dlg, IDC_HOSTNAME);
1015     hwndHostnameEdit = GetWindow(hwndHostname, GW_CHILD);
1016     OrigHostnameEditProc = (WNDPROC)GetWindowLong(hwndHostnameEdit, GWL_WNDPROC);
1017     SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)HostnameEditProc);
1018    
1019 yutakakn 2728 CheckRadioButton(dlg, IDC_HOSTTELNET, IDC_HOSTOTHER,
1020 maya 3003 pvar->settings.Enabled ? IDC_HOSTSSH : GetHNRec->
1021     Telnet ? IDC_HOSTTELNET : IDC_HOSTOTHER);
1022 yutakakn 2728 SendDlgItemMessage(dlg, IDC_HOSTTCPPORT, EM_LIMITTEXT, 5, 0);
1023     SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TCPPort, FALSE);
1024 maya 2980 #ifndef NO_INET6
1025 yutakakn 2728 for (i = 0; ProtocolFamilyList[i]; ++i) {
1026     SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_ADDSTRING,
1027 maya 3003 0, (LPARAM) ProtocolFamilyList[i]);
1028 yutakakn 2728 }
1029     SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, EM_LIMITTEXT,
1030 maya 3003 ProtocolFamilyMaxLength - 1, 0);
1031 yutakakn 2728 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_SETCURSEL, 0, 0);
1032 maya 2980 #endif /* NO_INET6 */
1033 yutakakn 2728
1034     /////// SSH version
1035     for (i = 0; ssh_version[i]; ++i) {
1036     SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_ADDSTRING,
1037 maya 3003 0, (LPARAM) ssh_version[i]);
1038 yutakakn 2728 }
1039     SendDlgItemMessage(dlg, IDC_SSH_VERSION, EM_LIMITTEXT,
1040 maya 3003 NUM_ELEM(ssh_version) - 1, 0);
1041 yutakakn 2728
1042 yutakakn 2734 if (pvar->settings.ssh_protocol_version == 1) {
1043     SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 0, 0); // SSH1
1044     } else {
1045 yutakakn 2728 SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 1, 0); // SSH2
1046     }
1047    
1048     if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1049     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE); // enabled
1050     } else {
1051     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1052     }
1053     /////// SSH version
1054    
1055    
1056     j = 0;
1057     w = 1;
1058 yutakapon 2996 if ((comports=DetectComPorts(ComPortTable, GetHNRec->MaxComPort, ComPortDesc)) >= 0) {
1059 doda 2964 for (i=0; i<comports; i++) {
1060 maya 3006 // MaxComPort ���z�����|�[�g���\��������
1061     if (ComPortTable[i] > GetHNRec->MaxComPort) {
1062     continue;
1063     }
1064    
1065 maya 3007 // �g�p�����|�[�g���\��������
1066     if (CheckCOMFlag(ComPortTable[i]) == 1) {
1067     continue;
1068     }
1069    
1070 maya 3020 _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", ComPortTable[i]);
1071 maya 2998 if (ComPortDesc[i] != NULL) {
1072     strncat_s(EntName, sizeof(EntName), ": ", _TRUNCATE);
1073     strncat_s(EntName, sizeof(EntName), ComPortDesc[i], _TRUNCATE);
1074     }
1075 doda 2964 SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
1076 maya 3003 0, (LPARAM)EntName);
1077 doda 2964 j++;
1078     if (GetHNRec->ComPort == ComPortTable[i])
1079     w = j;
1080     }
1081    
1082     } else {
1083     for (i = 1; i <= GetHNRec->MaxComPort; i++) {
1084 maya 3007 // �g�p�����|�[�g���\��������
1085     if (CheckCOMFlag(i) == 1) {
1086     continue;
1087     }
1088    
1089 maya 3020 _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", i);
1090 doda 2964 SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
1091 maya 3003 0, (LPARAM) EntName);
1092 doda 2964 j++;
1093     if (GetHNRec->ComPort == i)
1094     w = j;
1095     }
1096 yutakakn 2728 }
1097 doda 2964
1098 yutakakn 2728 if (j > 0)
1099     SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_SETCURSEL, w - 1, 0);
1100 doda 2982 else { /* All com ports are already used */
1101 yutakakn 2728 GetHNRec->PortType = IdTCPIP;
1102 doda 2982 enable_dlg_items(dlg, IDC_HOSTSERIAL, IDC_HOSTSERIAL, FALSE);
1103     }
1104 yutakakn 2728
1105 doda 2982 CheckRadioButton(dlg, IDC_HOSTTCPIP, IDC_HOSTSERIAL,
1106 maya 3003 IDC_HOSTTCPIP + GetHNRec->PortType - 1);
1107 doda 2982
1108 yutakakn 2803 if (GetHNRec->PortType == IdTCPIP) {
1109 yutakakn 2728 enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);
1110 yutakakn 2803
1111     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
1112     enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE);
1113     }
1114 maya 2980 #ifndef NO_INET6
1115 yutakakn 2728 else {
1116     enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1117 maya 3003 FALSE);
1118 yutakakn 2728 enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1119 maya 3003 IDC_HOSTTCPPROTOCOL, FALSE);
1120 yutakakn 2803
1121     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1122     enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)
1123 yutakakn 2728 }
1124     #else
1125     else
1126     enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1127     FALSE);
1128 maya 2980 #endif /* NO_INET6 */
1129 yutakakn 2728
1130     // Host dialog���t�H�[�J�X�������� (2004.10.2 yutaka)
1131 yutakakn 2803 if (GetHNRec->PortType == IdTCPIP) {
1132     HWND hwnd = GetDlgItem(dlg, IDC_HOSTNAME);
1133     SetFocus(hwnd);
1134     } else {
1135     HWND hwnd = GetDlgItem(dlg, IDC_HOSTCOM);
1136     SetFocus(hwnd);
1137 yutakakn 2728 }
1138    
1139 maya 2943 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1140     GetObject(font, sizeof(LOGFONT), &logfont);
1141 maya 2946 if (UTIL_get_lang_font("DLG_SYSTEM_FONT", dlg, &logfont, &DlgHostFont, pvar)) {
1142 maya 2943 SendDlgItemMessage(dlg, IDC_HOSTTCPIP, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1143     SendDlgItemMessage(dlg, IDC_HOSTNAMELABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1144 maya 2946 SendDlgItemMessage(dlg, IDC_HOSTNAME, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1145 maya 2943 SendDlgItemMessage(dlg, IDC_HISTORY, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1146     SendDlgItemMessage(dlg, IDC_SERVICELABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1147     SendDlgItemMessage(dlg, IDC_HOSTTELNET, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1148     SendDlgItemMessage(dlg, IDC_HOSTSSH, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1149     SendDlgItemMessage(dlg, IDC_HOSTOTHER, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1150     SendDlgItemMessage(dlg, IDC_HOSTTCPPORTLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1151 maya 2946 SendDlgItemMessage(dlg, IDC_HOSTTCPPORT, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1152 maya 2943 SendDlgItemMessage(dlg, IDC_SSH_VERSION_LABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1153 maya 2946 SendDlgItemMessage(dlg, IDC_SSH_VERSION, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1154 maya 2943 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOLLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1155 maya 2946 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1156 maya 2943 SendDlgItemMessage(dlg, IDC_HOSTSERIAL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1157     SendDlgItemMessage(dlg, IDC_HOSTCOMLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1158 maya 2946 SendDlgItemMessage(dlg, IDC_HOSTCOM, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1159 maya 2943 SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1160     SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1161     SendDlgItemMessage(dlg, IDC_HOSTHELP, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1162     }
1163     else {
1164     DlgHostFont = NULL;
1165     }
1166    
1167 yutakakn 2734 // SetFocus()���t�H�[�J�X���������������AFALSE�������K�v�������B
1168     // TRUE���������ATABSTOP�������������������R���g���[�����I�������B
1169     // (2004.11.23 yutaka)
1170     return FALSE;
1171     //return TRUE;
1172 yutakakn 2728
1173     case WM_COMMAND:
1174     switch (LOWORD(wParam)) {
1175     case IDOK:
1176     GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);
1177     if (GetHNRec != NULL) {
1178     if (IsDlgButtonChecked(dlg, IDC_HOSTTCPIP)) {
1179 maya 2980 #ifndef NO_INET6
1180 yutakakn 2728 char afstr[BUFSIZ];
1181 maya 2980 #endif /* NO_INET6 */
1182 yutakakn 2728 i = GetDlgItemInt(dlg, IDC_HOSTTCPPORT, &Ok, FALSE);
1183     if (Ok) {
1184     GetHNRec->TCPPort = i;
1185     } else {
1186 maya 2994 UTIL_get_lang_msg("MSG_TCPPORT_NAN_ERROR", pvar,
1187 maya 3003 "The TCP port must be a number.");
1188 maya 2937 MessageBox(dlg, pvar->ts->UIMsg,
1189 maya 3003 "Teraterm", MB_OK | MB_ICONEXCLAMATION);
1190 yutakakn 2728 return TRUE;
1191     }
1192 maya 2980 #ifndef NO_INET6
1193 yutakakn 2728 #define getaf(str) \
1194     ((strcmp((str), "IPv6") == 0) ? AF_INET6 : \
1195     ((strcmp((str), "IPv4") == 0) ? AF_INET : AF_UNSPEC))
1196     memset(afstr, 0, sizeof(afstr));
1197     GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOL, afstr,
1198 maya 3003 sizeof(afstr));
1199 yutakakn 2728 GetHNRec->ProtocolFamily = getaf(afstr);
1200 maya 2980 #endif /* NO_INET6 */
1201 yutakakn 2728 GetHNRec->PortType = IdTCPIP;
1202     GetDlgItemText(dlg, IDC_HOSTNAME, GetHNRec->HostName,
1203 maya 3003 HostNameMaxLength);
1204 yutakakn 2728 GetHNRec->Telnet = FALSE;
1205     pvar->hostdlg_activated = TRUE;
1206     pvar->hostdlg_Enabled = FALSE;
1207     if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
1208     GetHNRec->Telnet = TRUE;
1209     } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1210     pvar->hostdlg_Enabled = TRUE;
1211    
1212     // check SSH protocol version
1213     memset(afstr, 0, sizeof(afstr));
1214     GetDlgItemText(dlg, IDC_SSH_VERSION, afstr, sizeof(afstr));
1215 yutakakn 2850 if (_stricmp(afstr, "SSH1") == 0) {
1216 yutakakn 2728 pvar->settings.ssh_protocol_version = 1;
1217     } else {
1218     pvar->settings.ssh_protocol_version = 2;
1219     }
1220     }
1221 yutakakn 2846
1222     // host history check button
1223     if (SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_GETCHECK, 0, 0) == BST_CHECKED) {
1224     pvar->ts->HistoryList = 1;
1225     } else {
1226     pvar->ts->HistoryList = 0;
1227     }
1228    
1229 yutakakn 2728 } else {
1230     GetHNRec->PortType = IdSerial;
1231     GetHNRec->HostName[0] = 0;
1232     memset(EntName, 0, sizeof(EntName));
1233     GetDlgItemText(dlg, IDC_HOSTCOM, EntName,
1234 maya 3003 sizeof(EntName) - 1);
1235 doda 2982 if (strncmp(EntName, "COM", 3) == 0 && EntName[3] != '\0') {
1236 yutakapon 2997 #if 0
1237 doda 2982 GetHNRec->ComPort = (BYTE) (EntName[3]) - 0x30;
1238     if (strlen(EntName) > 4)
1239     GetHNRec->ComPort =
1240     GetHNRec->ComPort * 10 + (BYTE) (EntName[4]) -
1241     0x30;
1242 yutakapon 2997 #else
1243     GetHNRec->ComPort = atoi(&EntName[3]);
1244     #endif
1245 doda 2982 if (GetHNRec->ComPort > GetHNRec->MaxComPort)
1246     GetHNRec->ComPort = 1;
1247     } else {
1248     GetHNRec->ComPort = 1;
1249     }
1250 yutakakn 2728 }
1251     }
1252 maya 3009 SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
1253 yutakakn 2728 EndDialog(dlg, 1);
1254 maya 2943
1255 maya 2947 if (DlgHostFont != NULL) {
1256     DeleteObject(DlgHostFont);
1257 maya 2943 }
1258    
1259 yutakakn 2728 return TRUE;
1260    
1261     case IDCANCEL:
1262 maya 3009 SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
1263 yutakakn 2728 EndDialog(dlg, 0);
1264 maya 2943
1265 maya 2947 if (DlgHostFont != NULL) {
1266     DeleteObject(DlgHostFont);
1267 maya 2943 }
1268 maya 2994
1269 yutakakn 2728 return TRUE;
1270    
1271     case IDC_HOSTTCPIP:
1272     enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1273 maya 3003 TRUE);
1274 maya 2980 #ifndef NO_INET6
1275 yutakakn 2728 enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1276 maya 3003 IDC_HOSTTCPPROTOCOL, TRUE);
1277 maya 2980 #endif /* NO_INET6 */
1278 yutakakn 2728 enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);
1279    
1280 yutakakn 2734 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE); // disabled (2004.11.23 yutaka)
1281 yutakakn 2728 if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1282     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
1283     } else {
1284     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1285     }
1286    
1287 yutakakn 2847 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, TRUE); // disabled
1288    
1289 yutakakn 2728 return TRUE;
1290    
1291     case IDC_HOSTSERIAL:
1292     enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, TRUE);
1293     enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1294 maya 3003 FALSE);
1295 maya 2980 #ifndef NO_INET6
1296 yutakakn 2728 enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1297 maya 3003 IDC_HOSTTCPPROTOCOL, FALSE);
1298 maya 2980 #endif /* NO_INET6 */
1299 yutakakn 2728 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1300 yutakakn 2734 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)
1301 yutakakn 2728
1302 yutakakn 2847 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, FALSE); // disabled
1303    
1304 yutakakn 2728 return TRUE;
1305    
1306     case IDC_HOSTSSH:
1307     enable_dlg_items(dlg, IDC_SSH_VERSION,
1308 maya 3003 IDC_SSH_VERSION, TRUE);
1309 yutakakn 2728 goto hostssh_enabled;
1310    
1311     case IDC_HOSTTELNET:
1312     case IDC_HOSTOTHER:
1313     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1314     hostssh_enabled:
1315    
1316     GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);
1317    
1318     if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
1319     if (GetHNRec != NULL)
1320     SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TelPort,
1321 maya 3003 FALSE);
1322 yutakakn 2728 } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1323     SetDlgItemInt(dlg, IDC_HOSTTCPPORT, 22, FALSE);
1324     }
1325     return TRUE;
1326    
1327 maya 3009 case IDC_HOSTCOM:
1328     if(HIWORD(wParam) == CBN_DROPDOWN) {
1329     HWND hostcom = GetDlgItem(dlg, IDC_HOSTCOM);
1330     int count = SendMessage(hostcom, CB_GETCOUNT, 0, 0);
1331     int i, len, max_len = 0;
1332     char *lbl;
1333     HDC TmpDC = GetDC(hostcom);
1334     SIZE s;
1335     for (i=0; i<count; i++) {
1336     len = SendMessage(hostcom, CB_GETLBTEXTLEN, i, 0);
1337     lbl = (char *)calloc(len+1, sizeof(char));
1338     SendMessage(hostcom, CB_GETLBTEXT, i, (LPARAM)lbl);
1339     GetTextExtentPoint32(TmpDC, lbl, len, &s);
1340     if (s.cx > max_len)
1341     max_len = s.cx;
1342     free(lbl);
1343     }
1344     SendMessage(hostcom, CB_SETDROPPEDWIDTH,
1345     max_len + GetSystemMetrics(SM_CXVSCROLL), 0);
1346 maya 3004 }
1347 maya 3009 break;
1348 maya 3004
1349 yutakakn 2728 case IDC_HOSTHELP:
1350     PostMessage(GetParent(dlg), WM_USER_DLGHELP2, 0, 0);
1351     }
1352     }
1353     return FALSE;
1354     }
1355    
1356     static BOOL FAR PASCAL TTXGetHostName(HWND parent, PGetHNRec rec)
1357     {
1358     return (BOOL) DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_HOSTDLG),
1359 maya 3003 parent, TTXHostDlg, (LONG) rec);
1360 yutakakn 2728 }
1361    
1362     static void PASCAL FAR TTXGetUIHooks(TTXUIHooks FAR * hooks)
1363     {
1364     GET_VAR();
1365    
1366     *hooks->GetHostName = TTXGetHostName;
1367     }
1368    
1369     static void FAR PASCAL TTXReadINIFile(PCHAR fileName, PTTSet ts)
1370     {
1371     GET_VAR();
1372    
1373     (pvar->ReadIniFile) (fileName, ts);
1374     read_ssh_options(pvar, fileName);
1375     pvar->settings = *pvar->ts_SSH;
1376     notify_verbose_message(pvar, "Reading INI file", LOG_LEVEL_VERBOSE);
1377     FWDUI_load_settings(pvar);
1378     }
1379    
1380     static void FAR PASCAL TTXWriteINIFile(PCHAR fileName, PTTSet ts)
1381     {
1382     GET_VAR();
1383    
1384     (pvar->WriteIniFile) (fileName, ts);
1385     *pvar->ts_SSH = pvar->settings;
1386     clear_local_settings(pvar);
1387     notify_verbose_message(pvar, "Writing INI file", LOG_LEVEL_VERBOSE);
1388 maya 2909 write_ssh_options(pvar, fileName, pvar->ts_SSH, TRUE);
1389 yutakakn 2728 }
1390    
1391     static void read_ssh_options_from_user_file(PTInstVar pvar,
1392 maya 3003 char FAR * user_file_name)
1393 yutakakn 2728 {
1394     if (user_file_name[0] == '.') {
1395     read_ssh_options(pvar, user_file_name);
1396     } else {
1397     char buf[1024];
1398    
1399     get_teraterm_dir_relative_name(buf, sizeof(buf), user_file_name);
1400     read_ssh_options(pvar, buf);
1401     }
1402    
1403     pvar->settings = *pvar->ts_SSH;
1404     FWDUI_load_settings(pvar);
1405     }
1406    
1407 yutakakn 2784
1408     // @���u�����N���u�������B (2005.1.26 yutaka)
1409     static void replace_to_blank(char *src, char *dst, int dst_len)
1410     {
1411     int len, i;
1412    
1413     len = strlen(src);
1414     if (dst_len < len) // buffer overflow check
1415     return;
1416    
1417     for (i = 0 ; i < len ; i++) {
1418     if (src[i] == '@') { // @ ���o��������
1419     if (i < len - 1 && src[i + 1] == '@') { // �������� @ �����A�b�g�}�[�N���F������
1420     *dst++ = '@';
1421     i++;
1422     } else {
1423     *dst++ = ' '; // �������u��������
1424     }
1425     } else {
1426     *dst++ = src[i];
1427     }
1428     }
1429     *dst = '\0';
1430     }
1431    
1432 yutakakn 2728 /* returns 1 if the option text must be deleted */
1433     static int parse_option(PTInstVar pvar, char FAR * option)
1434     {
1435     if ((option[0] == '-' || option[0] == '/')) {
1436     if (MATCH_STR(option + 1, "ssh") == 0) {
1437     if (option[4] == 0) {
1438     pvar->settings.Enabled = 1;
1439 maya 3003 } else if (MATCH_STR(option + 4, "-L") == 0 ||
1440     MATCH_STR(option + 4, "-R") == 0 ||
1441     _stricmp(option + 4, "-X") == 0) {
1442 yutakakn 2728 if (pvar->settings.DefaultForwarding[0] == 0) {
1443 maya 2992 strncpy_s(pvar->settings.DefaultForwarding,
1444 maya 3003 sizeof(pvar->settings.DefaultForwarding),
1445     option + 5, _TRUNCATE);
1446 yutakakn 2728 } else {
1447 maya 2992 strncat_s(pvar->settings.DefaultForwarding,
1448 maya 3003 sizeof(pvar->settings.DefaultForwarding),
1449     ";", _TRUNCATE);
1450 maya 2992 strncat_s(pvar->settings.DefaultForwarding,
1451 maya 3003 sizeof(pvar->settings.DefaultForwarding),
1452     option + 5, _TRUNCATE);
1453 yutakakn 2728 }
1454     } else if (MATCH_STR(option + 4, "-f=") == 0) {
1455 maya 2911 read_ssh_options_from_user_file(pvar, option + 7);
1456 yutakakn 2728 } else if (MATCH_STR(option + 4, "-v") == 0) {
1457     pvar->settings.LogLevel = LOG_LEVEL_VERBOSE;
1458 maya 3003 } else if (_stricmp(option + 4, "-autologin") == 0 ||
1459     _stricmp(option + 4, "-autologon") == 0) {
1460 yutakakn 2728 pvar->settings.TryDefaultAuth = TRUE;
1461 yutakakn 2739
1462 maya 3067 } else if (_stricmp(option + 4, "-acceptall") == 0) {
1463     pvar->settings.LocalForwardingIdentityCheck = FALSE;
1464    
1465 yutakakn 2728 } else if (MATCH_STR(option + 4, "-consume=") == 0) {
1466 maya 2911 read_ssh_options_from_user_file(pvar, option + 13);
1467 yutakakn 2728 DeleteFile(option + 13);
1468 maya 2907
1469     // /ssh1 �� /ssh2 �I�v�V�������V�K���� (2006.9.16 maya)
1470     } else if (MATCH_STR(option + 4, "1") == 0) {
1471 maya 3072 pvar->settings.Enabled = 1;
1472 maya 2907 pvar->settings.ssh_protocol_version = 1;
1473     } else if (MATCH_STR(option + 4, "2") == 0) {
1474 maya 3072 pvar->settings.Enabled = 1;
1475 maya 2907 pvar->settings.ssh_protocol_version = 2;
1476    
1477 yutakakn 2728 } else {
1478     char buf[1024];
1479    
1480 maya 2994 UTIL_get_lang_msg("MSG_UNKNOWN_OPTION_ERROR", pvar,
1481 maya 3003 "Unrecognized command-line option: %s");
1482 maya 2992 _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg, option);
1483 yutakakn 2728
1484     MessageBox(NULL, buf, "TTSSH", MB_OK | MB_ICONEXCLAMATION);
1485     }
1486    
1487     return 1;
1488 maya 2915
1489     // ttermpro.exe �� /T= �w�������p�������A������������ (2006.10.19 maya)
1490     } else if (MATCH_STR_I(option + 1, "t=") == 0) {
1491 yutakakn 2728 if (strcmp(option + 3, "2") == 0) {
1492     pvar->settings.Enabled = 1;
1493     return 1;
1494     } else {
1495     pvar->settings.Enabled = 0;
1496     }
1497    
1498 maya 2915 // ttermpro.exe �� /F= �w������ TTSSH ������������ (2006.10.11 maya)
1499     } else if (MATCH_STR_I(option + 1, "f=") == 0) {
1500 maya 2913 read_ssh_options_from_user_file(pvar, option + 3);
1501    
1502 yutakakn 2728 // /1 ������ /2 �I�v�V�������V�K���� (2004.10.3 yutaka)
1503     } else if (MATCH_STR(option + 1, "1") == 0) {
1504     // command line: /ssh /1 is SSH1 only
1505     pvar->settings.ssh_protocol_version = 1;
1506    
1507     } else if (MATCH_STR(option + 1, "2") == 0) {
1508     // command line: /ssh /2 is SSH2 & SSH1
1509     pvar->settings.ssh_protocol_version = 2;
1510    
1511     } else if (MATCH_STR(option + 1, "nossh") == 0) {
1512     // '/nossh' �I�v�V�����������B
1513     // TERATERM.INI ��SSH���L�������������������A������Cygterm���N��������������
1514     // �����������������B(2004.10.11 yutaka)
1515     pvar->settings.Enabled = 0;
1516    
1517 maya 2907 } else if (MATCH_STR(option + 1, "telnet") == 0) {
1518     // '/telnet' ���w�������������������� '/nossh' ��������
1519     // SSH������������ (2006.9.16 maya)
1520     pvar->settings.Enabled = 0;
1521    
1522 yutakakn 2739 } else if (MATCH_STR(option + 1, "auth") == 0) {
1523 yutakakn 2784 // SSH2�������O�C���I�v�V����������
1524 yutakakn 2739 //
1525 yutakakn 2784 // SYNOPSIS: /ssh /auth=passowrd /user=���[�U�� /passwd=�p�X���[�h
1526     // /ssh /auth=publickey /user=���[�U�� /passwd=�p�X���[�h /keyfile=�p�X
1527     // EXAMPLE: /ssh /auth=password /user=nike /passwd=a@bc
1528     // /ssh /auth=publickey /user=foo /passwd=bar /keyfile=d:\tmp\id_rsa
1529     // NOTICE: �p�X���[�h���p�X�������������������A�u�����N���������� @ ���g�������B
1530 yutakakn 2739 //
1531 yutakakn 2784 // (2004.11.30 yutaka)
1532     // (2005.1.26 yutaka) ���������B���J���F���T�|�[�g�B
1533     //
1534 yutakakn 2739 pvar->ssh2_autologin = 1; // for SSH2 (2004.11.30 yutaka)
1535    
1536 maya 3025 if (MATCH_STR(option + 5, "=password") == 0) { // �p�X���[�h
1537 yutakakn 2784 //pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
1538     pvar->ssh2_authmethod = SSH_AUTH_PASSWORD;
1539 yutakakn 2739
1540 maya 3028 // /auth=challenge ������ (2007.10.5 maya)
1541     } else if (MATCH_STR(option + 5, "=challenge") == 0) { // keyboard-interactive�F��
1542 maya 3025 //pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
1543     pvar->ssh2_authmethod = SSH_AUTH_TIS;
1544    
1545 yutakakn 2784 } else if (MATCH_STR(option + 5, "=publickey") == 0) { // ���J���F��
1546     //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1547     pvar->ssh2_authmethod = SSH_AUTH_RSA;
1548    
1549 maya 3108 } else if (MATCH_STR(option + 5, "=pageant") == 0) { // ���J���F�� by Pageant
1550     //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1551     pvar->ssh2_authmethod = SSH_AUTH_PAGEANT;
1552    
1553 yutakakn 2739 } else {
1554     // TODO:
1555    
1556     }
1557    
1558     } else if (MATCH_STR(option + 1, "user=") == 0) {
1559 yutakakn 2784 replace_to_blank(option + 6, pvar->ssh2_username, sizeof(pvar->ssh2_username));
1560     //_snprintf(pvar->ssh2_username, sizeof(pvar->ssh2_username), "%s", option + 6);
1561 yutakakn 2739
1562     } else if (MATCH_STR(option + 1, "passwd=") == 0) {
1563 yutakakn 2784 replace_to_blank(option + 8, pvar->ssh2_password, sizeof(pvar->ssh2_password));
1564     //_snprintf(pvar->ssh2_password, sizeof(pvar->ssh2_password), "%s", option + 8);
1565 yutakakn 2739
1566 yutakakn 2784 } else if (MATCH_STR(option + 1, "keyfile=") == 0) {
1567     replace_to_blank(option + 9, pvar->ssh2_keyfile, sizeof(pvar->ssh2_keyfile));
1568    
1569 maya 2908 } else if (MATCH_STR(option + 1, "ask4passwd") == 0) {
1570     // �p�X���[�h������ (2006.9.18 maya)
1571     pvar->ask4passwd = 1;
1572    
1573 yutakakn 2728 }
1574    
1575 maya 2908 // �p�X���[�h�������������������O�C��������������
1576     // /auth ���F�����\�b�h���w�������������p������ (2006.9.18 maya)
1577     if (pvar->ask4passwd == 1) {
1578     pvar->ssh2_autologin = 0;
1579     }
1580    
1581 yutakakn 2728 }
1582    
1583     return 0;
1584     }
1585    
1586     static void FAR PASCAL TTXParseParam(PCHAR param, PTTSet ts,
1587 maya 3003 PCHAR DDETopic)
1588 yutakakn 2728 {
1589 maya 2911 // �X�y�[�X�������t�@�C�������F�������������C�� (2006.10.7 maya)
1590 yutakakn 2728 int i;
1591     BOOL inParam = FALSE;
1592     BOOL inQuotes = FALSE;
1593 maya 2911 BOOL inFileParam = FALSE;
1594 yutakakn 2728 PCHAR option = NULL;
1595     GET_VAR();
1596    
1597     if (pvar->hostdlg_activated) {
1598     pvar->settings.Enabled = pvar->hostdlg_Enabled;
1599     }
1600    
1601     for (i = 0; param[i] != 0; i++) {
1602 maya 2911 if (inQuotes ? param[i] == '"'
1603 maya 3003 : (param[i] == ' ' || param[i] == '\t')) {
1604 yutakakn 2728 if (option != NULL) {
1605     char ch = param[i];
1606 maya 2911 PCHAR Equal;
1607 yutakakn 2728
1608     param[i] = 0;
1609 maya 2911 Equal = strchr(option, '=');
1610     if (inFileParam && Equal != NULL && *(Equal + 1) == '"') {
1611 maya 2992 int buf_len = strlen(option) * sizeof(char);
1612 maya 2911 char *buf = (char *)calloc(strlen(option), sizeof(char));
1613 maya 2992 char c = option[Equal - option + 1];
1614     option[Equal - option + 1] = 0;
1615     strncat_s(buf, buf_len, option, _TRUNCATE);
1616     option[Equal - option + 1] = c;
1617     strncat_s(buf, buf_len, Equal + 2, _TRUNCATE);
1618 maya 3003 if (parse_option(pvar, *buf == '"' ? buf + 1 : buf)) {
1619 maya 2911 memset(option, ' ', i + 1 - (option - param));
1620     } else {
1621     param[i] = ch;
1622     }
1623     free(buf);
1624 yutakakn 2728 }
1625 maya 2911 else {
1626 maya 3003 if (parse_option(pvar, *option == '"' ? option + 1 : option)) {
1627 maya 2911 memset(option, ' ', i + 1 - (option - param));
1628     } else {
1629     param[i] = ch;
1630     }
1631     }
1632 yutakakn 2728 option = NULL;
1633     }
1634     inParam = FALSE;
1635     inQuotes = FALSE;
1636 maya 2911 inFileParam = FALSE;
1637 yutakakn 2728 } else if (!inParam) {
1638     if (param[i] == '"') {
1639     inQuotes = TRUE;
1640     inParam = TRUE;
1641     option = param + i;
1642     } else if (param[i] != ' ' && param[i] != '\t') {
1643     inParam = TRUE;
1644     option = param + i;
1645     }
1646 maya 2911 } else {
1647     if (option == NULL) {
1648     continue;
1649     }
1650     if ((option[0] == '-' || option[0] == '/') &&
1651 maya 3003 (MATCH_STR(option + 1, "ssh-f=") == 0 ||
1652     MATCH_STR(option + 1, "ssh-consume=") == 0 ||
1653     MATCH_STR_I(option + 1, "f=") == 0 ||
1654     MATCH_STR(option + 1, "keyfile=") == 0)) {
1655 maya 2911 if (param[i] == '"') {
1656     inQuotes = TRUE;
1657     }
1658     inFileParam = TRUE;
1659     }
1660 yutakakn 2728 }
1661     }
1662    
1663     if (option != NULL) {
1664 maya 2911 PCHAR Equal = strchr(option, '=');
1665     if (inFileParam && Equal != NULL && *(Equal + 1) == '"') {
1666 maya 2992 int buf_len = strlen(option) * sizeof(char);
1667 maya 2911 char *buf = (char *)calloc(strlen(option), sizeof(char));
1668 maya 2992 char c = option[Equal - option + 1];
1669     option[Equal - option + 1] = 0;
1670     strncat_s(buf, buf_len, option, _TRUNCATE);
1671     option[Equal - option + 1] = c;
1672     strncat_s(buf, buf_len, Equal + 2, _TRUNCATE);
1673 maya 3003 if (parse_option(pvar, *buf == '"' ? buf + 1 : buf)) {
1674 maya 2911 memset(option, ' ', i + 1 - (option - param));
1675     }
1676     free(buf);
1677 yutakakn 2728 }
1678 maya 2911 else {
1679     if (parse_option(pvar, option)) {
1680     memset(option, ' ', i - (option - param));
1681     }
1682     }
1683 yutakakn 2728 }
1684    
1685     FWDUI_load_settings(pvar);
1686    
1687     (pvar->ParseParam) (param, ts, DDETopic);
1688    
1689     }
1690    
1691     static void PASCAL FAR TTXGetSetupHooks(TTXSetupHooks FAR * hooks)
1692     {
1693     GET_VAR();
1694    
1695     pvar->ReadIniFile = *hooks->ReadIniFile;
1696     pvar->WriteIniFile = *hooks->WriteIniFile;
1697     pvar->ParseParam = *hooks->ParseParam;
1698    
1699     *hooks->ReadIniFile = TTXReadINIFile;
1700     *hooks->WriteIniFile = TTXWriteINIFile;
1701     *hooks->ParseParam = TTXParseParam;
1702     }
1703    
1704     static void PASCAL FAR TTXSetWinSize(int rows, int cols)
1705     {
1706     GET_VAR();
1707    
1708     SSH_notify_win_size(pvar, cols, rows);
1709     }
1710    
1711     static void insertMenuBeforeItem(HMENU menu, WORD beforeItemID, WORD flags,
1712 maya 3003 WORD newItemID, char FAR * text)
1713 yutakakn 2728 {
1714     int i, j;
1715    
1716     for (i = GetMenuItemCount(menu) - 1; i >= 0; i--) {
1717     HMENU submenu = GetSubMenu(menu, i);
1718    
1719     for (j = GetMenuItemCount(submenu) - 1; j >= 0; j--) {
1720     if (GetMenuItemID(submenu, j) == beforeItemID) {
1721 maya 3003 InsertMenu(submenu, j, MF_BYPOSITION | flags, newItemID, text);
1722 yutakakn 2728 return;
1723     }
1724     }
1725     }
1726     }
1727    
1728     static void PASCAL FAR TTXModifyMenu(HMENU menu)
1729     {
1730     GET_VAR();
1731    
1732     /* inserts before ID_HELP_ABOUT */
1733 maya 2994 UTIL_get_lang_msg("MENU_ABOUT", pvar, "About &TTSSH...");
1734 maya 2937 insertMenuBeforeItem(menu, 50990, MF_ENABLED, ID_ABOUTMENU, pvar->ts->UIMsg);
1735 yutakakn 2728
1736     /* inserts before ID_SETUP_TCPIP */
1737 maya 2994 UTIL_get_lang_msg("MENU_SSH", pvar, "SS&H...");
1738 maya 2937 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHSETUPMENU, pvar->ts->UIMsg);
1739 yutakakn 2728 /* inserts before ID_SETUP_TCPIP */
1740 maya 2994 UTIL_get_lang_msg("MENU_SSH_AUTH", pvar, "SSH &Authentication...");
1741 maya 2937 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHAUTHSETUPMENU, pvar->ts->UIMsg);
1742 yutakakn 2728 /* inserts before ID_SETUP_TCPIP */
1743 maya 2994 UTIL_get_lang_msg("MENU_SSH_FORWARD", pvar, "SSH F&orwarding...");
1744 maya 2937 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHFWDSETUPMENU, pvar->ts->UIMsg);
1745 maya 2994 UTIL_get_lang_msg("MENU_SSH_KEYGEN", pvar, "SSH KeyGe&nerator...");
1746 maya 2937 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHKEYGENMENU, pvar->ts->UIMsg);
1747 yutakapon 3074
1748     /* inserts before ID_FILE_CHANGEDIR */
1749     UTIL_get_lang_msg("MENU_SSH_SCP", pvar, "SSH SCP...");
1750     insertMenuBeforeItem(menu, 50170, MF_ENABLED, ID_SSHSCPMENU, pvar->ts->UIMsg);
1751 yutakakn 2728 }
1752    
1753     static void append_about_text(HWND dlg, char FAR * prefix, char FAR * msg)
1754     {
1755     SendDlgItemMessage(dlg, IDC_ABOUTTEXT, EM_REPLACESEL, 0,
1756 maya 3003 (LPARAM) prefix);
1757 yutakakn 2728 SendDlgItemMessage(dlg, IDC_ABOUTTEXT, EM_REPLACESEL, 0, (LPARAM) msg);
1758     SendDlgItemMessage(dlg, IDC_ABOUTTEXT, EM_REPLACESEL, 0,
1759 maya 3003 (LPARAM) (char FAR *) "\r\n");
1760 yutakakn 2728 }
1761    
1762 yutakakn 2792 // ���s�t�@�C�������o�[�W�������������� (2005.2.28 yutaka)
1763 yutakakn 2793 void get_file_version(char *exefile, int *major, int *minor, int *release, int *build)
1764 yutakakn 2792 {
1765     typedef struct {
1766     WORD wLanguage;
1767     WORD wCodePage;
1768     } LANGANDCODEPAGE, *LPLANGANDCODEPAGE;
1769     LPLANGANDCODEPAGE lplgcode;
1770     UINT unLen;
1771     DWORD size;
1772     char *buf = NULL;
1773     BOOL ret;
1774     int i;
1775     char fmt[80];
1776     char *pbuf;
1777    
1778     size = GetFileVersionInfoSize(exefile, NULL);
1779     if (size == 0) {
1780     goto error;
1781     }
1782     buf = malloc(size);
1783     ZeroMemory(buf, size);
1784    
1785     if (GetFileVersionInfo(exefile, 0, size, buf) == FALSE) {
1786     goto error;
1787     }
1788    
1789     ret = VerQueryValue(buf,
1790     "\\VarFileInfo\\Translation",
1791     (LPVOID *)&lplgcode, &unLen);
1792     if (ret == FALSE)
1793     goto error;
1794    
1795     for (i = 0 ; i < (int)(unLen / sizeof(LANGANDCODEPAGE)) ; i++) {
1796 maya 2992 _snprintf_s(fmt, sizeof(fmt), _TRUNCATE,
1797 maya 3003 "\\StringFileInfo\\%04x%04x\\FileVersion",
1798     lplgcode[i].wLanguage, lplgcode[i].wCodePage);
1799 yutakakn 2792 VerQueryValue(buf, fmt, &pbuf, &unLen);
1800     if (unLen > 0) { // get success
1801     int n, a, b, c, d;
1802    
1803     n = sscanf(pbuf, "%d, %d, %d, %d", &a, &b, &c, &d);
1804     if (n == 4) { // convert success
1805     *major = a;
1806     *minor = b;
1807     *release = c;
1808     *build = d;
1809     break;
1810     }
1811     }
1812     }
1813    
1814     free(buf);
1815     return;
1816    
1817     error:
1818     free(buf);
1819     *major = *minor = *release = *build = 0;
1820     }
1821    
1822 yutakakn 2728 static void init_about_dlg(PTInstVar pvar, HWND dlg)
1823     {
1824     char buf[1024];
1825 yutakakn 2792 int a, b, c, d;
1826 maya 2994 char uimsg[MAX_UIMSG];
1827    
1828     GetWindowText(dlg, uimsg, sizeof(uimsg));
1829     UTIL_get_lang_msg("DLG_ABOUT_TITLE", pvar, uimsg);
1830 maya 2937 SetWindowText(dlg, pvar->ts->UIMsg);
1831 maya 2994 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1832     UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1833 maya 2937 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1834    
1835 yutakakn 2792 // TTSSH���o�[�W�������������� (2005.2.28 yutaka)
1836     get_file_version("ttxssh.dll", &a, &b, &c, &d);
1837 maya 2992 _snprintf_s(buf, sizeof(buf), _TRUNCATE,
1838     "TTSSH\r\nTeraterm Secure Shell extension, %d.%d", a, b);
1839 yutakakn 2792 SendMessage(GetDlgItem(dlg, IDC_TTSSH_VERSION), WM_SETTEXT, 0, (LPARAM)buf);
1840    
1841 yutakakn 2782 // OpenSSL���o�[�W�������������� (2005.1.24 yutaka)
1842 yutakakn 2820 // ���������� (2005.5.11 yutaka)
1843     #ifdef OPENSSL_VERSION_TEXT
1844 yutakakn 2782 SendMessage(GetDlgItem(dlg, IDC_OPENSSL_VERSION), WM_SETTEXT, 0, (LPARAM)OPENSSL_VERSION_TEXT);
1845 yutakakn 2820 #else
1846     SendMessage(GetDlgItem(dlg, IDC_OPENSSL_VERSION), WM_SETTEXT, 0, (LPARAM)"Unknown");
1847     #endif
1848 yutakakn 2782
1849 yutakakn 2820 // zlib���o�[�W�������������� (2005.5.11 yutaka)
1850     #ifdef ZLIB_VERSION
1851 maya 2992 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "ZLib %s", ZLIB_VERSION);
1852 yutakakn 2820 #else
1853 yutakakn 2823 _snprintf(buf, sizeof(buf), "ZLib Unknown");
1854 yutakakn 2820 #endif
1855     SendMessage(GetDlgItem(dlg, IDC_ZLIB_VERSION), WM_SETTEXT, 0, (LPARAM)buf);
1856    
1857    
1858 yutakakn 2728 // TTSSH�_�C�A���O���\������SSH������������ (2004.10.30 yutaka)
1859     if (pvar->socket != INVALID_SOCKET) {
1860     if (SSHv1(pvar)) {
1861     SSH_get_server_ID_info(pvar, buf, sizeof(buf));
1862 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_SERVERID", pvar, "Server ID: ");
1863 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1864 yutakakn 2728 SSH_get_protocol_version_info(pvar, buf, sizeof(buf));
1865 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_PROTOCOL", pvar, "Using protocol: ");
1866 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1867 yutakakn 2728 CRYPT_get_cipher_info(pvar, buf, sizeof(buf));
1868 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_ENCRYPTION", pvar, "Encryption: ");
1869 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1870 yutakakn 2728 CRYPT_get_server_key_info(pvar, buf, sizeof(buf));
1871 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_SERVERKEY", pvar, "Server keys: ");
1872 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1873 yutakakn 2728 AUTH_get_auth_info(pvar, buf, sizeof(buf));
1874 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_AUTH", pvar, "Authentication: ");
1875 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1876 yutakakn 2728 SSH_get_compression_info(pvar, buf, sizeof(buf));
1877 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_COMP", pvar, "Compression: ");
1878 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1879 yutakakn 2728
1880     } else { // SSH2
1881     SSH_get_server_ID_info(pvar, buf, sizeof(buf));
1882 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_SERVERID", pvar, "Server ID: ");
1883 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1884 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_CLIENTID", pvar, "Client ID: ");
1885 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, pvar->client_version_string);
1886 yutakakn 2728
1887     SSH_get_protocol_version_info(pvar, buf, sizeof(buf));
1888 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_PROTOCOL", pvar, "Using protocol: ");
1889 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1890 yutakakn 2728
1891     if (pvar->kex_type == KEX_DH_GRP1_SHA1) {
1892 maya 2992 strncpy_s(buf, sizeof(buf), KEX_DH1, _TRUNCATE);
1893 yutakakn 2728 } else if (pvar->kex_type == KEX_DH_GRP14_SHA1) {
1894 maya 2992 strncpy_s(buf, sizeof(buf), KEX_DH14, _TRUNCATE);
1895 yutakakn 2728 } else {
1896 maya 2992 strncpy_s(buf, sizeof(buf), KEX_DHGEX, _TRUNCATE);
1897 yutakakn 2728 }
1898     append_about_text(dlg, "KEX: ", buf);
1899    
1900     if (pvar->hostkey_type == KEY_DSA) {
1901 maya 2992 strncpy_s(buf, sizeof(buf), "ssh-dss", _TRUNCATE);
1902 yutakakn 2728 } else {
1903 maya 2992 strncpy_s(buf, sizeof(buf), "ssh-rsa", _TRUNCATE);
1904 yutakakn 2728 }
1905 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_HOSTKEY", pvar, "Host Key: ");
1906 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1907 yutakakn 2728
1908 yutakakn 2758 // add HMAC algorithm (2004.12.17 yutaka)
1909     buf[0] = '\0';
1910     if (pvar->ctos_hmac == HMAC_SHA1) {
1911 maya 2992 strncat_s(buf, sizeof(buf), "hmac-sha1", _TRUNCATE);
1912 yutakakn 2758 } else if (pvar->ctos_hmac == HMAC_MD5) {
1913 maya 2992 strncat_s(buf, sizeof(buf), "hmac-md5", _TRUNCATE);
1914 yutakakn 2758 }
1915 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_TOSERVER", pvar, " to server, ");
1916 maya 2992 strncat_s(buf, sizeof(buf), pvar->ts->UIMsg, _TRUNCATE);
1917 yutakakn 2758 if (pvar->stoc_hmac == HMAC_SHA1) {
1918 maya 2992 strncat_s(buf, sizeof(buf), "hmac-sha1", _TRUNCATE);
1919 yutakakn 2758 } else if (pvar->stoc_hmac == HMAC_MD5) {
1920 maya 2992 strncat_s(buf, sizeof(buf), "hmac-md5", _TRUNCATE);
1921 yutakakn 2758 }
1922 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_FROMSERVER", pvar, " from server");
1923 maya 2992 strncat_s(buf, sizeof(buf), pvar->ts->UIMsg, _TRUNCATE);
1924 yutakakn 2758 append_about_text(dlg, "HMAC: ", buf);
1925    
1926 yutakakn 2728 CRYPT_get_cipher_info(pvar, buf, sizeof(buf));
1927 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_ENCRYPTION", pvar, "Encryption: ");
1928 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1929 yutakakn 2728 CRYPT_get_server_key_info(pvar, buf, sizeof(buf));
1930 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_SERVERKEY", pvar, "Server keys: ");
1931 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1932 maya 2994
1933 yutakakn 2728 AUTH_get_auth_info(pvar, buf, sizeof(buf));
1934 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_AUTH", pvar, "Authentication: ");
1935 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1936 yutakakn 2873
1937 yutakakn 2728 SSH_get_compression_info(pvar, buf, sizeof(buf));
1938 yutakakn 2873 if (pvar->ctos_compression == COMP_DELAYED) { // �x���p�P�b�g���k������ (2006.6.23 yutaka)
1939 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_COMPDELAY", pvar, "Delayed Compression: ");
1940 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1941 yutakakn 2873 } else {
1942 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_COMP", pvar, "Compression: ");
1943 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1944 yutakakn 2873 }
1945 yutakakn 2728 }
1946     }
1947     }
1948    
1949     static BOOL CALLBACK TTXAboutDlg(HWND dlg, UINT msg, WPARAM wParam,
1950 maya 3003 LPARAM lParam)
1951 yutakakn 2728 {
1952 maya 2937 LOGFONT logfont;
1953     HFONT font;
1954 maya 2994
1955 yutakakn 2728 switch (msg) {
1956     case WM_INITDIALOG:
1957 maya 2937 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1958     GetObject(font, sizeof(LOGFONT), &logfont);
1959 maya 2946 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAboutFont, pvar)) {
1960 maya 2937 SendDlgItemMessage(dlg, IDC_TTSSH_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1961     SendDlgItemMessage(dlg, IDC_SSHVERSIONS, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1962     SendDlgItemMessage(dlg, IDC_INCLUDES, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1963     SendDlgItemMessage(dlg, IDC_OPENSSL_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1964     SendDlgItemMessage(dlg, IDC_ZLIB_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1965     SendDlgItemMessage(dlg, IDC_WEBSITES, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1966     SendDlgItemMessage(dlg, IDC_CRYPTOGRAPHY, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1967     SendDlgItemMessage(dlg, IDC_CREDIT, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1968     SendDlgItemMessage(dlg, IDC_ABOUTTEXT, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1969     SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1970     }
1971     else {
1972     DlgAboutFont = NULL;
1973     }
1974 yutakakn 2728 init_about_dlg((PTInstVar) lParam, dlg);
1975     return TRUE;
1976     case WM_COMMAND:
1977     switch (LOWORD(wParam)) {
1978     case IDOK:
1979     EndDialog(dlg, 1);
1980 maya 2937 if (DlgAboutFont != NULL) {
1981     DeleteObject(DlgAboutFont);
1982     }
1983 yutakakn 2728 return TRUE;
1984     case IDCANCEL: /* there isn't a cancel button, but other Windows
1985     UI things can send this message */
1986     EndDialog(dlg, 0);
1987 maya 2937 if (DlgAboutFont != NULL) {
1988     DeleteObject(DlgAboutFont);
1989     }
1990 yutakakn 2728 return TRUE;
1991     }
1992     break;
1993     }
1994    
1995     return FALSE;
1996     }
1997    
1998     static char FAR *get_cipher_name(int cipher)
1999     {
2000     switch (cipher) {
2001     case SSH_CIPHER_NONE:
2002 maya 2994 UTIL_get_lang_msg("DLG_SSHSETUP_CIPHER_BORDER", pvar,
2003 maya 3003 "<ciphers below this line are disabled>");
2004 maya 2937 return pvar->ts->UIMsg;
2005 yutakakn 2728 case SSH_CIPHER_RC4:
2006 maya 3036 return "RC4(SSH1)";
2007 yutakakn 2728 case SSH_CIPHER_3DES:
2008 maya 3036 return "3DES(SSH1)";
2009 yutakakn 2728 case SSH_CIPHER_DES:
2010 maya 3036 return "DES(SSH1)";
2011 yutakakn 2728 case SSH_CIPHER_IDEA:
2012 maya 3036 return "IDEA(SSH1)";
2013 yutakakn 2728 case SSH_CIPHER_TSS:
2014 maya 3036 return "TSS(SSH1)";
2015 yutakakn 2728 case SSH_CIPHER_BLOWFISH:
2016 maya 3036 return "Blowfish(SSH1)";
2017 yutakakn 2728
2018     // for SSH2(yutaka)
2019 maya 3045 case SSH2_CIPHER_AES128:
2020 yutakakn 2728 return "AES128(SSH2)";
2021 maya 3045 case SSH2_CIPHER_AES192:
2022 maya 3040 return "AES192(SSH2)";
2023 maya 3045 case SSH2_CIPHER_AES256:
2024 maya 3036 return "AES256(SSH2)";
2025 maya 3045 case SSH2_CIPHER_3DES_CBC:
2026 yutakakn 2728 return "3DES-CBC(SSH2)";
2027 maya 3045 case SSH2_CIPHER_BLOWFISH:
2028     return "Blowfish(SSH2)";
2029 yutakakn 2728
2030     default:
2031     return NULL;
2032     }
2033     }
2034    
2035     static void set_move_button_status(HWND dlg)
2036     {
2037     HWND cipherControl = GetDlgItem(dlg, IDC_SSHCIPHERPREFS);
2038     int curPos = (int) SendMessage(cipherControl, LB_GETCURSEL, 0, 0);
2039     int maxPos = (int) SendMessage(cipherControl, LB_GETCOUNT, 0, 0) - 1;
2040    
2041 maya 3003 EnableWindow(GetDlgItem(dlg, IDC_SSHMOVECIPHERUP),
2042     curPos > 0 && curPos <= maxPos);
2043     EnableWindow(GetDlgItem(dlg, IDC_SSHMOVECIPHERDOWN),
2044     curPos >= 0 && curPos < maxPos);
2045 yutakakn 2728 }
2046    
2047     static void init_setup_dlg(PTInstVar pvar, HWND dlg)
2048     {
2049     HWND compressionControl = GetDlgItem(dlg, IDC_SSHCOMPRESSIONLEVEL);
2050     HWND cipherControl = GetDlgItem(dlg, IDC_SSHCIPHERPREFS);
2051     int i;
2052     int ch;
2053 maya 2994 char uimsg[MAX_UIMSG];
2054 maya 2937
2055 maya 2994 GetWindowText(dlg, uimsg, sizeof(uimsg));
2056     UTIL_get_lang_msg("DLG_SSHSETUP_TITLE", pvar, uimsg);
2057 maya 2937 SetWindowText(dlg, pvar->ts->UIMsg);
2058 maya 2994 GetDlgItemText(dlg, IDC_COMPRESSLABEL, uimsg, sizeof(uimsg));
2059     UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS", pvar, uimsg);
2060 maya 2937 SetDlgItemText(dlg, IDC_COMPRESSLABEL, pvar->ts->UIMsg);
2061 maya 2994 GetDlgItemText(dlg, IDC_COMPRESSNONE, uimsg, sizeof(uimsg));
2062     UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS_NONE", pvar, uimsg);
2063 maya 2937 SetDlgItemText(dlg, IDC_COMPRESSNONE, pvar->ts->UIMsg);
2064 maya 2994 GetDlgItemText(dlg, IDC_COMPRESSHIGH, uimsg, sizeof(uimsg));
2065     UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS_HIGHEST", pvar, uimsg);
2066 maya 2937 SetDlgItemText(dlg, IDC_COMPRESSHIGH, pvar->ts->UIMsg);
2067 maya 2994 GetDlgItemText(dlg, IDC_CIPHERORDER, uimsg, sizeof(uimsg));
2068     UTIL_get_lang_msg("DLG_SSHSETUP_CHIPER", pvar, uimsg);
2069 maya 2937 SetDlgItemText(dlg, IDC_CIPHERORDER, pvar->ts->UIMsg);
2070 maya 2994 GetDlgItemText(dlg, IDC_SSHMOVECIPHERUP, uimsg, sizeof(uimsg));
2071     UTIL_get_lang_msg("DLG_SSHSETUP_CHIPER_UP", pvar, uimsg);
2072 maya 2937 SetDlgItemText(dlg, IDC_SSHMOVECIPHERUP, pvar->ts->UIMsg);
2073 maya 2994 GetDlgItemText(dlg, IDC_SSHMOVECIPHERDOWN, uimsg, sizeof(uimsg));
2074     UTIL_get_lang_msg("DLG_SSHSETUP_CHIPER_DOWN", pvar, uimsg);
2075 maya 2937 SetDlgItemText(dlg, IDC_SSHMOVECIPHERDOWN, pvar->ts->UIMsg);
2076 maya 2994 GetDlgItemText(dlg, IDC_KNOWNHOSTS, uimsg, sizeof(uimsg));
2077     UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST", pvar, uimsg);
2078 maya 2937 SetDlgItemText(dlg, IDC_KNOWNHOSTS, pvar->ts->UIMsg);
2079 maya 2994 GetDlgItemText(dlg, IDC_CHOOSEREADWRITEFILE, uimsg, sizeof(uimsg));
2080     UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST_RW", pvar, uimsg);
2081 maya 2937 SetDlgItemText(dlg, IDC_CHOOSEREADWRITEFILE, pvar->ts->UIMsg);
2082 maya 2994 GetDlgItemText(dlg, IDC_CHOOSEREADONLYFILE, uimsg, sizeof(uimsg));
2083     UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST_RO", pvar, uimsg);
2084 maya 2937 SetDlgItemText(dlg, IDC_CHOOSEREADONLYFILE, pvar->ts->UIMsg);
2085 maya 2994 GetDlgItemText(dlg, IDC_HEARTBEATLABEL, uimsg, sizeof(uimsg));
2086     UTIL_get_lang_msg("DLG_SSHSETUP_HEARTBEAT", pvar, uimsg);
2087 maya 2937 SetDlgItemText(dlg, IDC_HEARTBEATLABEL, pvar->ts->UIMsg);
2088 maya 2994 GetDlgItemText(dlg, IDC_HEARTBEATLABEL2, uimsg, sizeof(uimsg));
2089     UTIL_get_lang_msg("DLG_SSHSETUP_HEARTBEAT_UNIT", pvar, uimsg);
2090 maya 2937 SetDlgItemText(dlg, IDC_HEARTBEATLABEL2, pvar->ts->UIMsg);
2091 maya 2994 GetDlgItemText(dlg, IDC_NOTICEBANNER, uimsg, sizeof(uimsg));
2092     UTIL_get_lang_msg("DLG_SSHSETUP_NOTICE", pvar, uimsg);
2093 maya 2937 SetDlgItemText(dlg, IDC_NOTICEBANNER, pvar->ts->UIMsg);
2094 maya 3002 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
2095 maya 2994 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
2096 maya 2937 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
2097 maya 3002 GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
2098 maya 2994 UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
2099 maya 2937 SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
2100    
2101 yutakakn 2728 SendMessage(compressionControl, TBM_SETRANGE, TRUE, MAKELONG(0, 9));
2102     SendMessage(compressionControl, TBM_SETPOS, TRUE,
2103 maya 3003 pvar->settings.CompressionLevel);
2104 yutakakn 2728
2105     normalize_cipher_order(pvar->settings.CipherOrder);
2106    
2107     for (i = 0; pvar->settings.CipherOrder[i] != 0; i++) {
2108     int cipher = pvar->settings.CipherOrder[i] - '0';
2109     char FAR *name = get_cipher_name(cipher);
2110    
2111     if (name != NULL) {
2112     SendMessage(cipherControl, LB_ADDSTRING, 0, (LPARAM) name);
2113     }
2114     }
2115    
2116     SendMessage(cipherControl, LB_SETCURSEL, 0, 0);
2117     set_move_button_status(dlg);
2118    
2119     for (i = 0; (ch = pvar->settings.KnownHostsFiles[i]) != 0 && ch != ';';
2120     i++) {
2121     }
2122     if (ch != 0) {
2123     pvar->settings.KnownHostsFiles[i] = 0;