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 3139 - (hide annotations) (download) (as text)
Fri Aug 1 16:29:01 2008 UTC (15 years, 8 months ago) by maya
Original Path: ttssh2/trunk/ttxssh/ttxssh.c
File MIME type: text/x-csrc
File size: 117711 byte(s) 
NT4.0で無理矢理32bitアイコンを表示しようとして崩れたアイコンが表示される問題を修正した。
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 doda 3134 /* Tera Term extension mechanism
30 yutakakn 2728 Robert O'Callahan (roc+tt@cs.cmu.edu)
31    
32 doda 3134 Tera Term by Takashi Teranishi (teranishi@rikaxp.riken.go.jp)
33 yutakakn 2728 */
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 doda 3134 This code makes lots of assumptions about the order in which Tera Term
103 yutakakn 2728 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 3139 int fuLoad = LR_DEFAULTCOLOR;
622    
623     if (is_NT4()) {
624     fuLoad = LR_VGACOLOR;
625     }
626    
627 maya 2897 // LoadIcon �������� LoadImage ���g�����������A
628     // 16x16 ���A�C�R���������I�������������������� (2006.8.9 maya)
629 maya 2896 if (SecureLargeIcon == NULL) {
630     SecureLargeIcon = LoadImage(hInst, MAKEINTRESOURCE(IDI_SECURETT),
631 maya 3139 IMAGE_ICON, 0, 0, fuLoad);
632 yutakakn 2728 }
633 maya 2896 if (SecureSmallIcon == NULL) {
634     SecureSmallIcon = LoadImage(hInst, MAKEINTRESOURCE(IDI_SECURETT),
635 maya 3139 IMAGE_ICON, 16, 16, fuLoad);
636 maya 2896 }
637 yutakakn 2728
638 maya 2896 if (SecureLargeIcon != NULL && SecureSmallIcon != NULL) {
639 maya 2897 // �������A�C�R���� WNDCLASS ���Z�b�g�����������������o���������� (2006.8.10 maya)
640     pvar->OldLargeIcon =
641     (HICON) GetClassLong(pvar->NotificationWindow, GCL_HICON);
642 yutakakn 2728 pvar->OldSmallIcon =
643     (HICON) SendMessage(pvar->NotificationWindow, WM_GETICON,
644 maya 3003 ICON_SMALL, 0);
645 maya 2897
646 yutakakn 2728 PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_BIG,
647 maya 3003 (LPARAM) SecureLargeIcon);
648 yutakakn 2728 PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_SMALL,
649 maya 3003 (LPARAM) SecureSmallIcon);
650 yutakakn 2728 }
651    
652     notify_verbose_message(pvar, "Entering secure mode",
653 maya 3003 LOG_LEVEL_VERBOSE);
654 yutakakn 2728 }
655    
656     void notify_closed_connection(PTInstVar pvar)
657     {
658 yutakakn 2766 SSH_notify_disconnecting(pvar, NULL);
659     AUTH_notify_disconnecting(pvar);
660     HOSTS_notify_disconnecting(pvar);
661    
662 yutakakn 2728 PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
663 maya 3003 pvar->socket, MAKELPARAM(FD_CLOSE, 0));
664 yutakakn 2728
665     }
666    
667     static void add_err_msg(PTInstVar pvar, char FAR * msg)
668     {
669     if (pvar->err_msg != NULL) {
670 maya 2992 int buf_len = strlen(pvar->err_msg) + 3 + strlen(msg);
671     char FAR *buf = (char FAR *) malloc(buf_len);
672 yutakakn 2728
673 maya 2992 strncpy_s(buf, buf_len, pvar->err_msg, _TRUNCATE);
674     strncat_s(buf, buf_len, "\n\n", _TRUNCATE);
675     strncat_s(buf, buf_len, msg, _TRUNCATE);
676 yutakakn 2728 free(pvar->err_msg);
677     pvar->err_msg = buf;
678     } else {
679     pvar->err_msg = _strdup(msg);
680     }
681     }
682    
683     void notify_nonfatal_error(PTInstVar pvar, char FAR * msg)
684     {
685     if (!pvar->showing_err) {
686 yutakakn 2868 // �������������������m���E�B���h�E�����������A�f�X�N�g�b�v���I�[�i�[������
687     // ���b�Z�[�W�{�b�N�X���o���������B(2006.6.11 yutaka)
688     if (pvar->NotificationWindow == NULL) {
689 maya 2994 UTIL_get_lang_msg("MSG_ERROR_NONFAITAL", pvar,
690 maya 3003 "Tera Term: not fatal error");
691 maya 2937 MessageBox(NULL, msg, pvar->ts->UIMsg, MB_OK|MB_ICONINFORMATION);
692 yutakakn 2868 msg[0] = '\0';
693    
694     } else {
695     PostMessage(pvar->NotificationWindow, WM_COMMAND,
696 maya 3003 ID_SSHASYNCMESSAGEBOX, 0);
697 yutakakn 2868 }
698 yutakakn 2728 }
699     if (msg[0] != 0) {
700     notify_verbose_message(pvar, msg, LOG_LEVEL_ERROR);
701     add_err_msg(pvar, msg);
702     }
703     }
704    
705     void notify_fatal_error(PTInstVar pvar, char FAR * msg)
706     {
707     if (msg[0] != 0) {
708     notify_verbose_message(pvar, msg, LOG_LEVEL_FATAL);
709     add_err_msg(pvar, msg);
710     }
711    
712     if (!pvar->fatal_error) {
713     pvar->fatal_error = TRUE;
714    
715     SSH_notify_disconnecting(pvar, msg);
716     AUTH_notify_disconnecting(pvar);
717     HOSTS_notify_disconnecting(pvar);
718    
719     PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
720 maya 3003 pvar->socket, MAKELPARAM(FD_CLOSE,
721     (pvar->PWSAGetLastError) ()));
722 yutakakn 2728 }
723     }
724    
725     void notify_verbose_message(PTInstVar pvar, char FAR * msg, int level)
726     {
727     if (level <= pvar->session_settings.LogLevel) {
728     char buf[1024];
729     int file;
730    
731     get_teraterm_dir_relative_name(buf, NUM_ELEM(buf), "TTSSH.LOG");
732     file = _open(buf, _O_RDWR | _O_APPEND | _O_CREAT | _O_TEXT,
733 maya 3003 _S_IREAD | _S_IWRITE);
734 yutakakn 2728
735     if (file >= 0) {
736     _write(file, msg, strlen(msg));
737     _write(file, "\n", 1);
738     _close(file);
739     }
740     }
741     }
742    
743     static void PASCAL FAR TTXOpenTCP(TTXSockHooks FAR * hooks)
744     {
745     GET_VAR();
746    
747     if (pvar->settings.Enabled) {
748 yutakakn 2805 char buf[1024] = "\n---------------------------------------------------------------------\nInitiating SSH session at ";
749 yutakakn 2728 struct tm FAR *newtime;
750     time_t long_time;
751    
752 maya 2970 // TCPLocalEcho/TCPCRSend ������������ (maya 2007.4.25)
753     pvar->ts->DisableTCPEchoCR = TRUE;
754    
755 yutakakn 2728 pvar->session_settings = pvar->settings;
756    
757     time(&long_time);
758     newtime = localtime(&long_time);
759 maya 2992 strncat_s(buf, sizeof(buf), asctime(newtime), _TRUNCATE);
760 yutakakn 2728 notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
761    
762     FWDUI_load_settings(pvar);
763    
764     pvar->cv->TelAutoDetect = FALSE;
765 doda 3134 /* This next line should not be needed because Tera Term's
766 yutakakn 2728 CommLib should find ts->Telnet == 0 ... but we'll do this
767     just to be on the safe side. */
768     pvar->cv->TelFlag = FALSE;
769    
770     pvar->Precv = *hooks->Precv;
771     pvar->Psend = *hooks->Psend;
772     pvar->PWSAAsyncSelect = *hooks->PWSAAsyncSelect;
773     pvar->Pconnect = *hooks->Pconnect;
774     pvar->PWSAGetLastError = *hooks->PWSAGetLastError;
775    
776     *hooks->Precv = TTXrecv;
777     *hooks->Psend = TTXsend;
778     *hooks->PWSAAsyncSelect = TTXWSAAsyncSelect;
779     *hooks->Pconnect = TTXconnect;
780    
781     SSH_open(pvar);
782     HOSTS_open(pvar);
783     FWDUI_open(pvar);
784 yutakakn 2875
785     // ������ myproposal �����f���������A�������O�����������B (2006.6.26 maya)
786     SSH2_update_cipher_myproposal(pvar);
787     SSH2_update_compression_myproposal(pvar);
788 yutakakn 2728 }
789     }
790    
791     static void PASCAL FAR TTXCloseTCP(TTXSockHooks FAR * hooks)
792     {
793     GET_VAR();
794    
795     if (pvar->session_settings.Enabled) {
796     pvar->socket = INVALID_SOCKET;
797    
798     notify_verbose_message(pvar, "Terminating SSH session...",
799 maya 3003 LOG_LEVEL_VERBOSE);
800 yutakakn 2728
801     *hooks->Precv = pvar->Precv;
802     *hooks->Psend = pvar->Psend;
803     *hooks->PWSAAsyncSelect = pvar->PWSAAsyncSelect;
804     *hooks->Pconnect = pvar->Pconnect;
805     }
806    
807     uninit_TTSSH(pvar);
808     init_TTSSH(pvar);
809     }
810    
811     static void enable_dlg_items(HWND dlg, int from, int to, BOOL enabled)
812     {
813     for (; from <= to; from++) {
814     EnableWindow(GetDlgItem(dlg, from), enabled);
815     }
816     }
817    
818 maya 3010 // C-p/C-n/C-b/C-f/C-a/C-e ���T�|�[�g (2007.9.5 maya)
819 yutakapon 3022 // C-d/C-k ���T�|�[�g (2007.10.3 yutaka)
820 maya 3008 // �h���b�v�_�E���������G�f�B�b�g�R���g���[����
821     // �T�u�N���X�������������E�C���h�E�v���V�[�W��
822 yutakapon 3022 WNDPROC OrigHostnameEditProc; // Original window procedure
823     LRESULT CALLBACK HostnameEditProc(HWND dlg, UINT msg,
824 maya 3008 WPARAM wParam, LPARAM lParam)
825     {
826     HWND parent;
827 yutakapon 3022 int max, select, len;
828 yutakapon 3048 char *str, *orgstr;
829 maya 3008
830     switch (msg) {
831     // �L�[�����������������m����
832     case WM_KEYDOWN:
833     if (GetKeyState(VK_CONTROL) < 0) {
834     switch (wParam) {
835 maya 3010 case 0x50: // Ctrl+p ... up
836 maya 3008 parent = GetParent(dlg);
837 maya 3010 select = SendMessage(parent, CB_GETCURSEL, 0, 0);
838     if (select > 0) {
839     PostMessage(parent, CB_SETCURSEL, select - 1, 0);
840 maya 3008 }
841     return 0;
842 maya 3010 case 0x4e: // Ctrl+n ... down
843 maya 3008 parent = GetParent(dlg);
844 maya 3010 max = SendMessage(parent, CB_GETCOUNT, 0, 0);
845     select = SendMessage(parent, CB_GETCURSEL, 0, 0);
846     if (select < max - 1) {
847     PostMessage(parent, CB_SETCURSEL, select + 1, 0);
848 maya 3008 }
849     return 0;
850 maya 3010 case 0x42: // Ctrl+b ... left
851     SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
852     PostMessage(dlg, EM_SETSEL, select-1, select-1);
853     return 0;
854     case 0x46: // Ctrl+f ... right
855     SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
856     max = GetWindowTextLength(dlg) ;
857     PostMessage(dlg, EM_SETSEL, select+1, select+1);
858     return 0;
859     case 0x41: // Ctrl+a ... home
860 maya 3009 PostMessage(dlg, EM_SETSEL, 0, 0);
861     return 0;
862 maya 3010 case 0x45: // Ctrl+e ... end
863     max = GetWindowTextLength(dlg) ;
864     PostMessage(dlg, EM_SETSEL, max, max);
865 maya 3009 return 0;
866 yutakapon 3022
867     case 0x44: // Ctrl+d
868     case 0x4b: // Ctrl+k
869 yutakapon 3048 case 0x55: // Ctrl+u
870 yutakapon 3022 SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
871     max = GetWindowTextLength(dlg);
872     max++; // '\0'
873 yutakapon 3048 orgstr = str = malloc(max);
874 yutakapon 3022 if (str != NULL) {
875     len = GetWindowText(dlg, str, max);
876     if (select >= 0 && select < len) {
877     if (wParam == 0x44) { // �J�[�\���z����������������������
878     memmove(&str[select], &str[select + 1], len - select - 1);
879     str[len - 1] = '\0';
880    
881     } else if (wParam == 0x4b) { // �J�[�\�������s��������������
882     str[select] = '\0';
883 yutakapon 3048
884 yutakapon 3022 }
885 yutakapon 3048 }
886 yutakapon 3022
887 yutakapon 3048 if (wParam == 0x55) { // �J�[�\����������������������
888     if (select >= len) {
889     str[0] = '\0';
890     } else {
891     str = &str[select];
892     }
893     select = 0;
894 yutakapon 3022 }
895 yutakapon 3048
896     SetWindowText(dlg, str);
897     SendMessage(dlg, EM_SETSEL, select, select);
898     free(orgstr);
899 yutakapon 3022 return 0;
900     }
901     break;
902 maya 3008 }
903     }
904     break;
905    
906 maya 3010 // �����L�[��������������������������������������������
907 maya 3008 case WM_CHAR:
908     switch (wParam) {
909 maya 3009 case 0x01:
910 maya 3010 case 0x02:
911 yutakapon 3022 case 0x04:
912 maya 3009 case 0x05:
913 maya 3010 case 0x06:
914 yutakapon 3022 case 0x0b:
915 maya 3008 case 0x0e:
916     case 0x10:
917 yutakapon 3048 case 0x15:
918 maya 3008 return 0;
919     }
920     }
921    
922     return CallWindowProc(OrigHostnameEditProc, dlg, msg, wParam, lParam);
923     }
924    
925 yutakakn 2728 static BOOL CALLBACK TTXHostDlg(HWND dlg, UINT msg, WPARAM wParam,
926 maya 3003 LPARAM lParam)
927 yutakakn 2728 {
928     static char *ssh_version[] = {"SSH1", "SSH2", NULL};
929     PGetHNRec GetHNRec;
930 yutakapon 2996 char EntName[128];
931 yutakakn 2728 char TempHost[HostNameMaxLength + 1];
932     WORD i, j, w;
933 maya 3021 WORD ComPortTable[MAXCOMPORT];
934 yutakapon 2996 static char *ComPortDesc[MAXCOMPORT];
935 doda 2964 int comports;
936 yutakakn 2728 BOOL Ok;
937 maya 2943 LOGFONT logfont;
938     HFONT font;
939 maya 2994 char uimsg[MAX_UIMSG];
940 maya 3099 static HWND hwndHostname = NULL; // HOSTNAME dropdown
941     static HWND hwndHostnameEdit = NULL; // Edit control on HOSTNAME dropdown
942 yutakakn 2728
943     GET_VAR();
944    
945     switch (msg) {
946     case WM_INITDIALOG:
947     GetHNRec = (PGetHNRec) lParam;
948     SetWindowLong(dlg, DWL_USER, lParam);
949    
950 maya 2994 GetWindowText(dlg, uimsg, sizeof(uimsg));
951     UTIL_get_lang_msg("DLG_HOST_TITLE", pvar, uimsg);
952 maya 2937 SetWindowText(dlg, pvar->ts->UIMsg);
953 maya 2994 GetDlgItemText(dlg, IDC_HOSTNAMELABEL, uimsg, sizeof(uimsg));
954 maya 3114 UTIL_get_lang_msg("DLG_HOST_TCPIPHOST", pvar, uimsg);
955 maya 2937 SetDlgItemText(dlg, IDC_HOSTNAMELABEL, pvar->ts->UIMsg);
956 maya 2994 GetDlgItemText(dlg, IDC_HISTORY, uimsg, sizeof(uimsg));
957 maya 3114 UTIL_get_lang_msg("DLG_HOST_TCPIPHISTORY", pvar, uimsg);
958 maya 2937 SetDlgItemText(dlg, IDC_HISTORY, pvar->ts->UIMsg);
959 maya 2994 GetDlgItemText(dlg, IDC_SERVICELABEL, uimsg, sizeof(uimsg));
960 maya 3114 UTIL_get_lang_msg("DLG_HOST_TCPIPSERVICE", pvar, uimsg);
961 maya 2937 SetDlgItemText(dlg, IDC_SERVICELABEL, pvar->ts->UIMsg);
962 maya 2994 GetDlgItemText(dlg, IDC_HOSTOTHER, uimsg, sizeof(uimsg));
963 maya 3114 UTIL_get_lang_msg("DLG_HOST_TCPIPOTHER", pvar, uimsg);
964 maya 2937 SetDlgItemText(dlg, IDC_HOSTOTHER, pvar->ts->UIMsg);
965 maya 2994 GetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, uimsg, sizeof(uimsg));
966 maya 3114 UTIL_get_lang_msg("DLG_HOST_TCPIPPORT", pvar, uimsg);
967 maya 2937 SetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, pvar->ts->UIMsg);
968 maya 2994 GetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, uimsg, sizeof(uimsg));
969 maya 3114 UTIL_get_lang_msg("DLG_HOST_TCPIPSSHVERSION", pvar, uimsg);
970 maya 2937 SetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, pvar->ts->UIMsg);
971 maya 2994 GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, uimsg, sizeof(uimsg));
972 maya 3114 UTIL_get_lang_msg("DLG_HOST_TCPIPPROTOCOL", pvar, uimsg);
973 maya 2937 SetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, pvar->ts->UIMsg);
974 maya 2994 GetDlgItemText(dlg, IDC_HOSTSERIAL, uimsg, sizeof(uimsg));
975     UTIL_get_lang_msg("DLG_HOST_SERIAL", pvar, uimsg);
976 maya 2937 SetDlgItemText(dlg, IDC_HOSTSERIAL, pvar->ts->UIMsg);
977 maya 2994 GetDlgItemText(dlg, IDC_HOSTCOMLABEL, uimsg, sizeof(uimsg));
978 maya 3114 UTIL_get_lang_msg("DLG_HOST_SERIALPORT", pvar, uimsg);
979 maya 2937 SetDlgItemText(dlg, IDC_HOSTCOMLABEL, pvar->ts->UIMsg);
980 maya 2994 GetDlgItemText(dlg, IDC_HOSTHELP, uimsg, sizeof(uimsg));
981     UTIL_get_lang_msg("DLG_HOST_HELP", pvar, uimsg);
982 maya 2937 SetDlgItemText(dlg, IDC_HOSTHELP, pvar->ts->UIMsg);
983 maya 2994 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
984     UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
985 maya 2937 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
986 maya 2994 GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
987     UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
988 maya 2937 SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
989    
990 yutakakn 2846 // �z�X�g�q�X�g�����`�F�b�N�{�b�N�X������ (2005.10.21 yutaka)
991     if (pvar->ts->HistoryList > 0) {
992     SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_CHECKED, 0);
993     } else {
994     SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_UNCHECKED, 0);
995     }
996    
997 yutakakn 2728 if (GetHNRec->PortType == IdFile)
998     GetHNRec->PortType = IdTCPIP;
999    
1000 maya 2992 strncpy_s(EntName, sizeof(EntName), "Host", _TRUNCATE);
1001 yutakakn 2728
1002     i = 1;
1003     do {
1004 maya 2992 _snprintf_s(&EntName[4], sizeof(EntName)-4, _TRUNCATE, "%d", i);
1005 yutakakn 2728 GetPrivateProfileString("Hosts", EntName, "",
1006 maya 3003 TempHost, sizeof(TempHost),
1007     GetHNRec->SetupFN);
1008 yutakakn 2728 if (strlen(TempHost) > 0)
1009     SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_ADDSTRING,
1010 maya 3003 0, (LPARAM) TempHost);
1011 yutakakn 2728 i++;
1012 maya 3005 } while ((i <= MAXHOSTLIST) && (strlen(TempHost) > 0));
1013 yutakakn 2728
1014     SendDlgItemMessage(dlg, IDC_HOSTNAME, EM_LIMITTEXT,
1015 maya 3003 HostNameMaxLength - 1, 0);
1016 yutakakn 2728
1017     SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_SETCURSEL, 0, 0);
1018    
1019 maya 3008 // C-n/C-p ���������T�u�N���X�� (2007.9.4 maya)
1020     hwndHostname = GetDlgItem(dlg, IDC_HOSTNAME);
1021     hwndHostnameEdit = GetWindow(hwndHostname, GW_CHILD);
1022     OrigHostnameEditProc = (WNDPROC)GetWindowLong(hwndHostnameEdit, GWL_WNDPROC);
1023     SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)HostnameEditProc);
1024    
1025 yutakakn 2728 CheckRadioButton(dlg, IDC_HOSTTELNET, IDC_HOSTOTHER,
1026 maya 3003 pvar->settings.Enabled ? IDC_HOSTSSH : GetHNRec->
1027     Telnet ? IDC_HOSTTELNET : IDC_HOSTOTHER);
1028 yutakakn 2728 SendDlgItemMessage(dlg, IDC_HOSTTCPPORT, EM_LIMITTEXT, 5, 0);
1029     SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TCPPort, FALSE);
1030 maya 2980 #ifndef NO_INET6
1031 yutakakn 2728 for (i = 0; ProtocolFamilyList[i]; ++i) {
1032     SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_ADDSTRING,
1033 maya 3003 0, (LPARAM) ProtocolFamilyList[i]);
1034 yutakakn 2728 }
1035     SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, EM_LIMITTEXT,
1036 maya 3003 ProtocolFamilyMaxLength - 1, 0);
1037 yutakakn 2728 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_SETCURSEL, 0, 0);
1038 maya 2980 #endif /* NO_INET6 */
1039 yutakakn 2728
1040     /////// SSH version
1041     for (i = 0; ssh_version[i]; ++i) {
1042     SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_ADDSTRING,
1043 maya 3003 0, (LPARAM) ssh_version[i]);
1044 yutakakn 2728 }
1045     SendDlgItemMessage(dlg, IDC_SSH_VERSION, EM_LIMITTEXT,
1046 maya 3003 NUM_ELEM(ssh_version) - 1, 0);
1047 yutakakn 2728
1048 yutakakn 2734 if (pvar->settings.ssh_protocol_version == 1) {
1049     SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 0, 0); // SSH1
1050     } else {
1051 yutakakn 2728 SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 1, 0); // SSH2
1052     }
1053    
1054     if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1055     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE); // enabled
1056     } else {
1057     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1058     }
1059     /////// SSH version
1060    
1061    
1062     j = 0;
1063     w = 1;
1064 yutakapon 2996 if ((comports=DetectComPorts(ComPortTable, GetHNRec->MaxComPort, ComPortDesc)) >= 0) {
1065 doda 2964 for (i=0; i<comports; i++) {
1066 maya 3006 // MaxComPort ���z�����|�[�g���\��������
1067     if (ComPortTable[i] > GetHNRec->MaxComPort) {
1068     continue;
1069     }
1070    
1071 maya 3007 // �g�p�����|�[�g���\��������
1072     if (CheckCOMFlag(ComPortTable[i]) == 1) {
1073     continue;
1074     }
1075    
1076 maya 3020 _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", ComPortTable[i]);
1077 maya 2998 if (ComPortDesc[i] != NULL) {
1078     strncat_s(EntName, sizeof(EntName), ": ", _TRUNCATE);
1079     strncat_s(EntName, sizeof(EntName), ComPortDesc[i], _TRUNCATE);
1080     }
1081 doda 2964 SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
1082 maya 3003 0, (LPARAM)EntName);
1083 doda 2964 j++;
1084     if (GetHNRec->ComPort == ComPortTable[i])
1085     w = j;
1086     }
1087    
1088     } else {
1089     for (i = 1; i <= GetHNRec->MaxComPort; i++) {
1090 maya 3007 // �g�p�����|�[�g���\��������
1091     if (CheckCOMFlag(i) == 1) {
1092     continue;
1093     }
1094    
1095 maya 3020 _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", i);
1096 doda 2964 SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
1097 maya 3003 0, (LPARAM) EntName);
1098 doda 2964 j++;
1099     if (GetHNRec->ComPort == i)
1100     w = j;
1101     }
1102 yutakakn 2728 }
1103 doda 2964
1104 yutakakn 2728 if (j > 0)
1105     SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_SETCURSEL, w - 1, 0);
1106 doda 2982 else { /* All com ports are already used */
1107 yutakakn 2728 GetHNRec->PortType = IdTCPIP;
1108 doda 2982 enable_dlg_items(dlg, IDC_HOSTSERIAL, IDC_HOSTSERIAL, FALSE);
1109     }
1110 yutakakn 2728
1111 doda 2982 CheckRadioButton(dlg, IDC_HOSTTCPIP, IDC_HOSTSERIAL,
1112 maya 3003 IDC_HOSTTCPIP + GetHNRec->PortType - 1);
1113 doda 2982
1114 yutakakn 2803 if (GetHNRec->PortType == IdTCPIP) {
1115 yutakakn 2728 enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);
1116 yutakakn 2803
1117     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
1118     enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE);
1119     }
1120 maya 2980 #ifndef NO_INET6
1121 yutakakn 2728 else {
1122     enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1123 maya 3003 FALSE);
1124 yutakakn 2728 enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1125 maya 3003 IDC_HOSTTCPPROTOCOL, FALSE);
1126 yutakakn 2803
1127     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1128     enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)
1129 yutakakn 2728 }
1130     #else
1131     else
1132     enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1133     FALSE);
1134 maya 2980 #endif /* NO_INET6 */
1135 yutakakn 2728
1136     // Host dialog���t�H�[�J�X�������� (2004.10.2 yutaka)
1137 yutakakn 2803 if (GetHNRec->PortType == IdTCPIP) {
1138     HWND hwnd = GetDlgItem(dlg, IDC_HOSTNAME);
1139     SetFocus(hwnd);
1140     } else {
1141     HWND hwnd = GetDlgItem(dlg, IDC_HOSTCOM);
1142     SetFocus(hwnd);
1143 yutakakn 2728 }
1144    
1145 maya 2943 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1146     GetObject(font, sizeof(LOGFONT), &logfont);
1147 maya 2946 if (UTIL_get_lang_font("DLG_SYSTEM_FONT", dlg, &logfont, &DlgHostFont, pvar)) {
1148 maya 2943 SendDlgItemMessage(dlg, IDC_HOSTTCPIP, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1149     SendDlgItemMessage(dlg, IDC_HOSTNAMELABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1150 maya 2946 SendDlgItemMessage(dlg, IDC_HOSTNAME, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1151 maya 2943 SendDlgItemMessage(dlg, IDC_HISTORY, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1152     SendDlgItemMessage(dlg, IDC_SERVICELABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1153     SendDlgItemMessage(dlg, IDC_HOSTTELNET, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1154     SendDlgItemMessage(dlg, IDC_HOSTSSH, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1155     SendDlgItemMessage(dlg, IDC_HOSTOTHER, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1156     SendDlgItemMessage(dlg, IDC_HOSTTCPPORTLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1157 maya 2946 SendDlgItemMessage(dlg, IDC_HOSTTCPPORT, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1158 maya 2943 SendDlgItemMessage(dlg, IDC_SSH_VERSION_LABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1159 maya 2946 SendDlgItemMessage(dlg, IDC_SSH_VERSION, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1160 maya 2943 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOLLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1161 maya 2946 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1162 maya 2943 SendDlgItemMessage(dlg, IDC_HOSTSERIAL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1163     SendDlgItemMessage(dlg, IDC_HOSTCOMLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1164 maya 2946 SendDlgItemMessage(dlg, IDC_HOSTCOM, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1165 maya 2943 SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1166     SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1167     SendDlgItemMessage(dlg, IDC_HOSTHELP, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1168     }
1169     else {
1170     DlgHostFont = NULL;
1171     }
1172    
1173 yutakakn 2734 // SetFocus()���t�H�[�J�X���������������AFALSE�������K�v�������B
1174     // TRUE���������ATABSTOP�������������������R���g���[�����I�������B
1175     // (2004.11.23 yutaka)
1176     return FALSE;
1177     //return TRUE;
1178 yutakakn 2728
1179     case WM_COMMAND:
1180     switch (LOWORD(wParam)) {
1181     case IDOK:
1182     GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);
1183     if (GetHNRec != NULL) {
1184     if (IsDlgButtonChecked(dlg, IDC_HOSTTCPIP)) {
1185 maya 2980 #ifndef NO_INET6
1186 yutakakn 2728 char afstr[BUFSIZ];
1187 maya 2980 #endif /* NO_INET6 */
1188 yutakakn 2728 i = GetDlgItemInt(dlg, IDC_HOSTTCPPORT, &Ok, FALSE);
1189     if (Ok) {
1190     GetHNRec->TCPPort = i;
1191     } else {
1192 maya 2994 UTIL_get_lang_msg("MSG_TCPPORT_NAN_ERROR", pvar,
1193 maya 3003 "The TCP port must be a number.");
1194 maya 2937 MessageBox(dlg, pvar->ts->UIMsg,
1195 doda 3134 "Tera Term", MB_OK | MB_ICONEXCLAMATION);
1196 yutakakn 2728 return TRUE;
1197     }
1198 maya 2980 #ifndef NO_INET6
1199 yutakakn 2728 #define getaf(str) \
1200     ((strcmp((str), "IPv6") == 0) ? AF_INET6 : \
1201     ((strcmp((str), "IPv4") == 0) ? AF_INET : AF_UNSPEC))
1202     memset(afstr, 0, sizeof(afstr));
1203     GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOL, afstr,
1204 maya 3003 sizeof(afstr));
1205 yutakakn 2728 GetHNRec->ProtocolFamily = getaf(afstr);
1206 maya 2980 #endif /* NO_INET6 */
1207 yutakakn 2728 GetHNRec->PortType = IdTCPIP;
1208     GetDlgItemText(dlg, IDC_HOSTNAME, GetHNRec->HostName,
1209 maya 3003 HostNameMaxLength);
1210 yutakakn 2728 GetHNRec->Telnet = FALSE;
1211     pvar->hostdlg_activated = TRUE;
1212     pvar->hostdlg_Enabled = FALSE;
1213     if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
1214     GetHNRec->Telnet = TRUE;
1215     } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1216     pvar->hostdlg_Enabled = TRUE;
1217    
1218     // check SSH protocol version
1219     memset(afstr, 0, sizeof(afstr));
1220     GetDlgItemText(dlg, IDC_SSH_VERSION, afstr, sizeof(afstr));
1221 yutakakn 2850 if (_stricmp(afstr, "SSH1") == 0) {
1222 yutakakn 2728 pvar->settings.ssh_protocol_version = 1;
1223     } else {
1224     pvar->settings.ssh_protocol_version = 2;
1225     }
1226     }
1227 yutakakn 2846
1228     // host history check button
1229     if (SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_GETCHECK, 0, 0) == BST_CHECKED) {
1230     pvar->ts->HistoryList = 1;
1231     } else {
1232     pvar->ts->HistoryList = 0;
1233     }
1234    
1235 yutakakn 2728 } else {
1236     GetHNRec->PortType = IdSerial;
1237     GetHNRec->HostName[0] = 0;
1238     memset(EntName, 0, sizeof(EntName));
1239     GetDlgItemText(dlg, IDC_HOSTCOM, EntName,
1240 maya 3003 sizeof(EntName) - 1);
1241 doda 2982 if (strncmp(EntName, "COM", 3) == 0 && EntName[3] != '\0') {
1242 yutakapon 2997 #if 0
1243 doda 2982 GetHNRec->ComPort = (BYTE) (EntName[3]) - 0x30;
1244     if (strlen(EntName) > 4)
1245     GetHNRec->ComPort =
1246     GetHNRec->ComPort * 10 + (BYTE) (EntName[4]) -
1247     0x30;
1248 yutakapon 2997 #else
1249     GetHNRec->ComPort = atoi(&EntName[3]);
1250     #endif
1251 doda 2982 if (GetHNRec->ComPort > GetHNRec->MaxComPort)
1252     GetHNRec->ComPort = 1;
1253     } else {
1254     GetHNRec->ComPort = 1;
1255     }
1256 yutakakn 2728 }
1257     }
1258 maya 3009 SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
1259 yutakakn 2728 EndDialog(dlg, 1);
1260 maya 2943
1261 maya 2947 if (DlgHostFont != NULL) {
1262     DeleteObject(DlgHostFont);
1263 maya 2943 }
1264    
1265 yutakakn 2728 return TRUE;
1266    
1267     case IDCANCEL:
1268 maya 3009 SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
1269 yutakakn 2728 EndDialog(dlg, 0);
1270 maya 2943
1271 maya 2947 if (DlgHostFont != NULL) {
1272     DeleteObject(DlgHostFont);
1273 maya 2943 }
1274 maya 2994
1275 yutakakn 2728 return TRUE;
1276    
1277     case IDC_HOSTTCPIP:
1278     enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1279 maya 3003 TRUE);
1280 maya 2980 #ifndef NO_INET6
1281 yutakakn 2728 enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1282 maya 3003 IDC_HOSTTCPPROTOCOL, TRUE);
1283 maya 2980 #endif /* NO_INET6 */
1284 yutakakn 2728 enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);
1285    
1286 yutakakn 2734 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE); // disabled (2004.11.23 yutaka)
1287 yutakakn 2728 if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1288     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
1289     } else {
1290     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1291     }
1292    
1293 yutakakn 2847 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, TRUE); // disabled
1294    
1295 yutakakn 2728 return TRUE;
1296    
1297     case IDC_HOSTSERIAL:
1298     enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, TRUE);
1299     enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1300 maya 3003 FALSE);
1301 maya 2980 #ifndef NO_INET6
1302 yutakakn 2728 enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1303 maya 3003 IDC_HOSTTCPPROTOCOL, FALSE);
1304 maya 2980 #endif /* NO_INET6 */
1305 yutakakn 2728 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1306 yutakakn 2734 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)
1307 yutakakn 2728
1308 yutakakn 2847 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, FALSE); // disabled
1309    
1310 yutakakn 2728 return TRUE;
1311    
1312     case IDC_HOSTSSH:
1313     enable_dlg_items(dlg, IDC_SSH_VERSION,
1314 maya 3003 IDC_SSH_VERSION, TRUE);
1315 yutakakn 2728 goto hostssh_enabled;
1316    
1317     case IDC_HOSTTELNET:
1318     case IDC_HOSTOTHER:
1319     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1320     hostssh_enabled:
1321    
1322     GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);
1323    
1324     if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
1325     if (GetHNRec != NULL)
1326     SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TelPort,
1327 maya 3003 FALSE);
1328 yutakakn 2728 } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1329     SetDlgItemInt(dlg, IDC_HOSTTCPPORT, 22, FALSE);
1330     }
1331     return TRUE;
1332    
1333 maya 3009 case IDC_HOSTCOM:
1334     if(HIWORD(wParam) == CBN_DROPDOWN) {
1335     HWND hostcom = GetDlgItem(dlg, IDC_HOSTCOM);
1336     int count = SendMessage(hostcom, CB_GETCOUNT, 0, 0);
1337     int i, len, max_len = 0;
1338     char *lbl;
1339     HDC TmpDC = GetDC(hostcom);
1340     SIZE s;
1341     for (i=0; i<count; i++) {
1342     len = SendMessage(hostcom, CB_GETLBTEXTLEN, i, 0);
1343     lbl = (char *)calloc(len+1, sizeof(char));
1344     SendMessage(hostcom, CB_GETLBTEXT, i, (LPARAM)lbl);
1345     GetTextExtentPoint32(TmpDC, lbl, len, &s);
1346     if (s.cx > max_len)
1347     max_len = s.cx;
1348     free(lbl);
1349     }
1350     SendMessage(hostcom, CB_SETDROPPEDWIDTH,
1351     max_len + GetSystemMetrics(SM_CXVSCROLL), 0);
1352 maya 3004 }
1353 maya 3009 break;
1354 maya 3004
1355 yutakakn 2728 case IDC_HOSTHELP:
1356     PostMessage(GetParent(dlg), WM_USER_DLGHELP2, 0, 0);
1357     }
1358     }
1359     return FALSE;
1360     }
1361    
1362     static BOOL FAR PASCAL TTXGetHostName(HWND parent, PGetHNRec rec)
1363     {
1364     return (BOOL) DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_HOSTDLG),
1365 maya 3003 parent, TTXHostDlg, (LONG) rec);
1366 yutakakn 2728 }
1367    
1368     static void PASCAL FAR TTXGetUIHooks(TTXUIHooks FAR * hooks)
1369     {
1370     GET_VAR();
1371    
1372     *hooks->GetHostName = TTXGetHostName;
1373     }
1374    
1375     static void FAR PASCAL TTXReadINIFile(PCHAR fileName, PTTSet ts)
1376     {
1377     GET_VAR();
1378    
1379     (pvar->ReadIniFile) (fileName, ts);
1380     read_ssh_options(pvar, fileName);
1381     pvar->settings = *pvar->ts_SSH;
1382     notify_verbose_message(pvar, "Reading INI file", LOG_LEVEL_VERBOSE);
1383     FWDUI_load_settings(pvar);
1384     }
1385    
1386     static void FAR PASCAL TTXWriteINIFile(PCHAR fileName, PTTSet ts)
1387     {
1388     GET_VAR();
1389    
1390     (pvar->WriteIniFile) (fileName, ts);
1391     *pvar->ts_SSH = pvar->settings;
1392     clear_local_settings(pvar);
1393     notify_verbose_message(pvar, "Writing INI file", LOG_LEVEL_VERBOSE);
1394 maya 2909 write_ssh_options(pvar, fileName, pvar->ts_SSH, TRUE);
1395 yutakakn 2728 }
1396    
1397     static void read_ssh_options_from_user_file(PTInstVar pvar,
1398 maya 3003 char FAR * user_file_name)
1399 yutakakn 2728 {
1400     if (user_file_name[0] == '.') {
1401     read_ssh_options(pvar, user_file_name);
1402     } else {
1403     char buf[1024];
1404    
1405     get_teraterm_dir_relative_name(buf, sizeof(buf), user_file_name);
1406     read_ssh_options(pvar, buf);
1407     }
1408    
1409     pvar->settings = *pvar->ts_SSH;
1410     FWDUI_load_settings(pvar);
1411     }
1412    
1413 yutakakn 2784
1414     // @���u�����N���u�������B (2005.1.26 yutaka)
1415     static void replace_to_blank(char *src, char *dst, int dst_len)
1416     {
1417     int len, i;
1418    
1419     len = strlen(src);
1420     if (dst_len < len) // buffer overflow check
1421     return;
1422    
1423     for (i = 0 ; i < len ; i++) {
1424     if (src[i] == '@') { // @ ���o��������
1425     if (i < len - 1 && src[i + 1] == '@') { // �������� @ �����A�b�g�}�[�N���F������
1426     *dst++ = '@';
1427     i++;
1428     } else {
1429     *dst++ = ' '; // �������u��������
1430     }
1431     } else {
1432     *dst++ = src[i];
1433     }
1434     }
1435     *dst = '\0';
1436     }
1437    
1438 yutakakn 2728 /* returns 1 if the option text must be deleted */
1439     static int parse_option(PTInstVar pvar, char FAR * option)
1440     {
1441     if ((option[0] == '-' || option[0] == '/')) {
1442     if (MATCH_STR(option + 1, "ssh") == 0) {
1443     if (option[4] == 0) {
1444     pvar->settings.Enabled = 1;
1445 maya 3003 } else if (MATCH_STR(option + 4, "-L") == 0 ||
1446     MATCH_STR(option + 4, "-R") == 0 ||
1447     _stricmp(option + 4, "-X") == 0) {
1448 yutakakn 2728 if (pvar->settings.DefaultForwarding[0] == 0) {
1449 maya 2992 strncpy_s(pvar->settings.DefaultForwarding,
1450 maya 3003 sizeof(pvar->settings.DefaultForwarding),
1451     option + 5, _TRUNCATE);
1452 yutakakn 2728 } else {
1453 maya 2992 strncat_s(pvar->settings.DefaultForwarding,
1454 maya 3003 sizeof(pvar->settings.DefaultForwarding),
1455     ";", _TRUNCATE);
1456 maya 2992 strncat_s(pvar->settings.DefaultForwarding,
1457 maya 3003 sizeof(pvar->settings.DefaultForwarding),
1458     option + 5, _TRUNCATE);
1459 yutakakn 2728 }
1460     } else if (MATCH_STR(option + 4, "-f=") == 0) {
1461 maya 2911 read_ssh_options_from_user_file(pvar, option + 7);
1462 yutakakn 2728 } else if (MATCH_STR(option + 4, "-v") == 0) {
1463     pvar->settings.LogLevel = LOG_LEVEL_VERBOSE;
1464 maya 3003 } else if (_stricmp(option + 4, "-autologin") == 0 ||
1465     _stricmp(option + 4, "-autologon") == 0) {
1466 yutakakn 2728 pvar->settings.TryDefaultAuth = TRUE;
1467 yutakakn 2739
1468 maya 3067 } else if (_stricmp(option + 4, "-acceptall") == 0) {
1469     pvar->settings.LocalForwardingIdentityCheck = FALSE;
1470    
1471 yutakakn 2728 } else if (MATCH_STR(option + 4, "-consume=") == 0) {
1472 maya 2911 read_ssh_options_from_user_file(pvar, option + 13);
1473 yutakakn 2728 DeleteFile(option + 13);
1474 maya 2907
1475     // /ssh1 �� /ssh2 �I�v�V�������V�K���� (2006.9.16 maya)
1476     } else if (MATCH_STR(option + 4, "1") == 0) {
1477 maya 3072 pvar->settings.Enabled = 1;
1478 maya 2907 pvar->settings.ssh_protocol_version = 1;
1479     } else if (MATCH_STR(option + 4, "2") == 0) {
1480 maya 3072 pvar->settings.Enabled = 1;
1481 maya 2907 pvar->settings.ssh_protocol_version = 2;
1482    
1483 yutakakn 2728 } else {
1484     char buf[1024];
1485    
1486 maya 2994 UTIL_get_lang_msg("MSG_UNKNOWN_OPTION_ERROR", pvar,
1487 maya 3003 "Unrecognized command-line option: %s");
1488 maya 2992 _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg, option);
1489 yutakakn 2728
1490     MessageBox(NULL, buf, "TTSSH", MB_OK | MB_ICONEXCLAMATION);
1491     }
1492    
1493     return 1;
1494 maya 2915
1495     // ttermpro.exe �� /T= �w�������p�������A������������ (2006.10.19 maya)
1496     } else if (MATCH_STR_I(option + 1, "t=") == 0) {
1497 yutakakn 2728 if (strcmp(option + 3, "2") == 0) {
1498     pvar->settings.Enabled = 1;
1499     return 1;
1500     } else {
1501     pvar->settings.Enabled = 0;
1502     }
1503    
1504 maya 2915 // ttermpro.exe �� /F= �w������ TTSSH ������������ (2006.10.11 maya)
1505     } else if (MATCH_STR_I(option + 1, "f=") == 0) {
1506 maya 2913 read_ssh_options_from_user_file(pvar, option + 3);
1507    
1508 yutakakn 2728 // /1 ������ /2 �I�v�V�������V�K���� (2004.10.3 yutaka)
1509     } else if (MATCH_STR(option + 1, "1") == 0) {
1510     // command line: /ssh /1 is SSH1 only
1511     pvar->settings.ssh_protocol_version = 1;
1512    
1513     } else if (MATCH_STR(option + 1, "2") == 0) {
1514     // command line: /ssh /2 is SSH2 & SSH1
1515     pvar->settings.ssh_protocol_version = 2;
1516    
1517     } else if (MATCH_STR(option + 1, "nossh") == 0) {
1518     // '/nossh' �I�v�V�����������B
1519     // TERATERM.INI ��SSH���L�������������������A������Cygterm���N��������������
1520     // �����������������B(2004.10.11 yutaka)
1521     pvar->settings.Enabled = 0;
1522    
1523 maya 2907 } else if (MATCH_STR(option + 1, "telnet") == 0) {
1524     // '/telnet' ���w�������������������� '/nossh' ��������
1525     // SSH������������ (2006.9.16 maya)
1526     pvar->settings.Enabled = 0;
1527    
1528 yutakakn 2739 } else if (MATCH_STR(option + 1, "auth") == 0) {
1529 yutakakn 2784 // SSH2�������O�C���I�v�V����������
1530 yutakakn 2739 //
1531 yutakakn 2784 // SYNOPSIS: /ssh /auth=passowrd /user=���[�U�� /passwd=�p�X���[�h
1532     // /ssh /auth=publickey /user=���[�U�� /passwd=�p�X���[�h /keyfile=�p�X
1533     // EXAMPLE: /ssh /auth=password /user=nike /passwd=a@bc
1534     // /ssh /auth=publickey /user=foo /passwd=bar /keyfile=d:\tmp\id_rsa
1535     // NOTICE: �p�X���[�h���p�X�������������������A�u�����N���������� @ ���g�������B
1536 yutakakn 2739 //
1537 yutakakn 2784 // (2004.11.30 yutaka)
1538     // (2005.1.26 yutaka) ���������B���J���F���T�|�[�g�B
1539     //
1540 yutakakn 2739 pvar->ssh2_autologin = 1; // for SSH2 (2004.11.30 yutaka)
1541    
1542 maya 3025 if (MATCH_STR(option + 5, "=password") == 0) { // �p�X���[�h
1543 yutakakn 2784 //pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
1544     pvar->ssh2_authmethod = SSH_AUTH_PASSWORD;
1545 yutakakn 2739
1546 maya 3028 // /auth=challenge ������ (2007.10.5 maya)
1547     } else if (MATCH_STR(option + 5, "=challenge") == 0) { // keyboard-interactive�F��
1548 maya 3025 //pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
1549     pvar->ssh2_authmethod = SSH_AUTH_TIS;
1550    
1551 yutakakn 2784 } else if (MATCH_STR(option + 5, "=publickey") == 0) { // ���J���F��
1552     //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1553     pvar->ssh2_authmethod = SSH_AUTH_RSA;
1554    
1555 maya 3108 } else if (MATCH_STR(option + 5, "=pageant") == 0) { // ���J���F�� by Pageant
1556     //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1557     pvar->ssh2_authmethod = SSH_AUTH_PAGEANT;
1558    
1559 yutakakn 2739 } else {
1560     // TODO:
1561    
1562     }
1563    
1564     } else if (MATCH_STR(option + 1, "user=") == 0) {
1565 yutakakn 2784 replace_to_blank(option + 6, pvar->ssh2_username, sizeof(pvar->ssh2_username));
1566     //_snprintf(pvar->ssh2_username, sizeof(pvar->ssh2_username), "%s", option + 6);
1567 yutakakn 2739
1568     } else if (MATCH_STR(option + 1, "passwd=") == 0) {
1569 yutakakn 2784 replace_to_blank(option + 8, pvar->ssh2_password, sizeof(pvar->ssh2_password));
1570     //_snprintf(pvar->ssh2_password, sizeof(pvar->ssh2_password), "%s", option + 8);
1571 yutakakn 2739
1572 yutakakn 2784 } else if (MATCH_STR(option + 1, "keyfile=") == 0) {
1573     replace_to_blank(option + 9, pvar->ssh2_keyfile, sizeof(pvar->ssh2_keyfile));
1574    
1575 maya 2908 } else if (MATCH_STR(option + 1, "ask4passwd") == 0) {
1576     // �p�X���[�h������ (2006.9.18 maya)
1577     pvar->ask4passwd = 1;
1578    
1579 yutakakn 2728 }
1580    
1581 maya 2908 // �p�X���[�h�������������������O�C��������������
1582     // /auth ���F�����\�b�h���w�������������p������ (2006.9.18 maya)
1583     if (pvar->ask4passwd == 1) {
1584     pvar->ssh2_autologin = 0;
1585     }
1586    
1587 yutakakn 2728 }
1588    
1589     return 0;
1590     }
1591    
1592     static void FAR PASCAL TTXParseParam(PCHAR param, PTTSet ts,
1593 maya 3003 PCHAR DDETopic)
1594 yutakakn 2728 {
1595 maya 2911 // �X�y�[�X�������t�@�C�������F�������������C�� (2006.10.7 maya)
1596 yutakakn 2728 int i;
1597     BOOL inParam = FALSE;
1598     BOOL inQuotes = FALSE;
1599 maya 2911 BOOL inFileParam = FALSE;
1600 yutakakn 2728 PCHAR option = NULL;
1601     GET_VAR();
1602    
1603     if (pvar->hostdlg_activated) {
1604     pvar->settings.Enabled = pvar->hostdlg_Enabled;
1605     }
1606    
1607     for (i = 0; param[i] != 0; i++) {
1608 maya 2911 if (inQuotes ? param[i] == '"'
1609 maya 3003 : (param[i] == ' ' || param[i] == '\t')) {
1610 yutakakn 2728 if (option != NULL) {
1611     char ch = param[i];
1612 maya 2911 PCHAR Equal;
1613 yutakakn 2728
1614     param[i] = 0;
1615 maya 2911 Equal = strchr(option, '=');
1616     if (inFileParam && Equal != NULL && *(Equal + 1) == '"') {
1617 maya 2992 int buf_len = strlen(option) * sizeof(char);
1618 maya 2911 char *buf = (char *)calloc(strlen(option), sizeof(char));
1619 maya 2992 char c = option[Equal - option + 1];
1620     option[Equal - option + 1] = 0;
1621     strncat_s(buf, buf_len, option, _TRUNCATE);
1622     option[Equal - option + 1] = c;
1623     strncat_s(buf, buf_len, Equal + 2, _TRUNCATE);
1624 maya 3003 if (parse_option(pvar, *buf == '"' ? buf + 1 : buf)) {
1625 maya 2911 memset(option, ' ', i + 1 - (option - param));
1626     } else {
1627     param[i] = ch;
1628     }
1629     free(buf);
1630 yutakakn 2728 }
1631 maya 2911 else {
1632 maya 3003 if (parse_option(pvar, *option == '"' ? option + 1 : option)) {
1633 maya 2911 memset(option, ' ', i + 1 - (option - param));
1634     } else {
1635     param[i] = ch;
1636     }
1637     }
1638 yutakakn 2728 option = NULL;
1639     }
1640     inParam = FALSE;
1641     inQuotes = FALSE;
1642 maya 2911 inFileParam = FALSE;
1643 yutakakn 2728 } else if (!inParam) {
1644     if (param[i] == '"') {
1645     inQuotes = TRUE;
1646     inParam = TRUE;
1647     option = param + i;
1648     } else if (param[i] != ' ' && param[i] != '\t') {
1649     inParam = TRUE;
1650     option = param + i;
1651     }
1652 maya 2911 } else {
1653     if (option == NULL) {
1654     continue;
1655     }
1656     if ((option[0] == '-' || option[0] == '/') &&
1657 maya 3003 (MATCH_STR(option + 1, "ssh-f=") == 0 ||
1658     MATCH_STR(option + 1, "ssh-consume=") == 0 ||
1659     MATCH_STR_I(option + 1, "f=") == 0 ||
1660     MATCH_STR(option + 1, "keyfile=") == 0)) {
1661 maya 2911 if (param[i] == '"') {
1662     inQuotes = TRUE;
1663     }
1664     inFileParam = TRUE;
1665     }
1666 yutakakn 2728 }
1667     }
1668    
1669     if (option != NULL) {
1670 maya 2911 PCHAR Equal = strchr(option, '=');
1671     if (inFileParam && Equal != NULL && *(Equal + 1) == '"') {
1672 maya 2992 int buf_len = strlen(option) * sizeof(char);
1673 maya 2911 char *buf = (char *)calloc(strlen(option), sizeof(char));
1674 maya 2992 char c = option[Equal - option + 1];
1675     option[Equal - option + 1] = 0;
1676     strncat_s(buf, buf_len, option, _TRUNCATE);
1677     option[Equal - option + 1] = c;
1678     strncat_s(buf, buf_len, Equal + 2, _TRUNCATE);
1679 maya 3003 if (parse_option(pvar, *buf == '"' ? buf + 1 : buf)) {
1680 maya 2911 memset(option, ' ', i + 1 - (option - param));
1681     }
1682     free(buf);
1683 yutakakn 2728 }
1684 maya 2911 else {
1685     if (parse_option(pvar, option)) {
1686     memset(option, ' ', i - (option - param));
1687     }
1688     }
1689 yutakakn 2728 }
1690    
1691     FWDUI_load_settings(pvar);
1692    
1693     (pvar->ParseParam) (param, ts, DDETopic);
1694    
1695     }
1696    
1697     static void PASCAL FAR TTXGetSetupHooks(TTXSetupHooks FAR * hooks)
1698     {
1699     GET_VAR();
1700    
1701     pvar->ReadIniFile = *hooks->ReadIniFile;
1702     pvar->WriteIniFile = *hooks->WriteIniFile;
1703     pvar->ParseParam = *hooks->ParseParam;
1704    
1705     *hooks->ReadIniFile = TTXReadINIFile;
1706     *hooks->WriteIniFile = TTXWriteINIFile;
1707     *hooks->ParseParam = TTXParseParam;
1708     }
1709    
1710     static void PASCAL FAR TTXSetWinSize(int rows, int cols)
1711     {
1712     GET_VAR();
1713    
1714     SSH_notify_win_size(pvar, cols, rows);
1715     }
1716    
1717     static void insertMenuBeforeItem(HMENU menu, WORD beforeItemID, WORD flags,
1718 maya 3003 WORD newItemID, char FAR * text)
1719 yutakakn 2728 {
1720     int i, j;
1721    
1722     for (i = GetMenuItemCount(menu) - 1; i >= 0; i--) {
1723     HMENU submenu = GetSubMenu(menu, i);
1724    
1725     for (j = GetMenuItemCount(submenu) - 1; j >= 0; j--) {
1726     if (GetMenuItemID(submenu, j) == beforeItemID) {
1727 maya 3003 InsertMenu(submenu, j, MF_BYPOSITION | flags, newItemID, text);
1728 yutakakn 2728 return;
1729     }
1730     }
1731     }
1732     }
1733    
1734     static void PASCAL FAR TTXModifyMenu(HMENU menu)
1735     {
1736     GET_VAR();
1737    
1738     /* inserts before ID_HELP_ABOUT */
1739 maya 2994 UTIL_get_lang_msg("MENU_ABOUT", pvar, "About &TTSSH...");
1740 maya 2937 insertMenuBeforeItem(menu, 50990, MF_ENABLED, ID_ABOUTMENU, pvar->ts->UIMsg);
1741 yutakakn 2728
1742     /* inserts before ID_SETUP_TCPIP */
1743 maya 2994 UTIL_get_lang_msg("MENU_SSH", pvar, "SS&H...");
1744 maya 2937 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHSETUPMENU, pvar->ts->UIMsg);
1745 yutakakn 2728 /* inserts before ID_SETUP_TCPIP */
1746 maya 2994 UTIL_get_lang_msg("MENU_SSH_AUTH", pvar, "SSH &Authentication...");
1747 maya 2937 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHAUTHSETUPMENU, pvar->ts->UIMsg);
1748 yutakakn 2728 /* inserts before ID_SETUP_TCPIP */
1749 maya 2994 UTIL_get_lang_msg("MENU_SSH_FORWARD", pvar, "SSH F&orwarding...");
1750 maya 2937 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHFWDSETUPMENU, pvar->ts->UIMsg);
1751 maya 2994 UTIL_get_lang_msg("MENU_SSH_KEYGEN", pvar, "SSH KeyGe&nerator...");
1752 maya 2937 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHKEYGENMENU, pvar->ts->UIMsg);
1753 yutakapon 3074
1754     /* inserts before ID_FILE_CHANGEDIR */
1755     UTIL_get_lang_msg("MENU_SSH_SCP", pvar, "SSH SCP...");
1756     insertMenuBeforeItem(menu, 50170, MF_ENABLED, ID_SSHSCPMENU, pvar->ts->UIMsg);
1757 yutakakn 2728 }
1758    
1759     static void append_about_text(HWND dlg, char FAR * prefix, char FAR * msg)
1760     {
1761     SendDlgItemMessage(dlg, IDC_ABOUTTEXT, EM_REPLACESEL, 0,
1762 maya 3003 (LPARAM) prefix);
1763 yutakakn 2728 SendDlgItemMessage(dlg, IDC_ABOUTTEXT, EM_REPLACESEL, 0, (LPARAM) msg);
1764     SendDlgItemMessage(dlg, IDC_ABOUTTEXT, EM_REPLACESEL, 0,
1765 maya 3003 (LPARAM) (char FAR *) "\r\n");
1766 yutakakn 2728 }
1767    
1768 yutakakn 2792 // ���s�t�@�C�������o�[�W�������������� (2005.2.28 yutaka)
1769 yutakakn 2793 void get_file_version(char *exefile, int *major, int *minor, int *release, int *build)
1770 yutakakn 2792 {
1771     typedef struct {
1772     WORD wLanguage;
1773     WORD wCodePage;
1774     } LANGANDCODEPAGE, *LPLANGANDCODEPAGE;
1775     LPLANGANDCODEPAGE lplgcode;
1776     UINT unLen;
1777     DWORD size;
1778     char *buf = NULL;
1779     BOOL ret;
1780     int i;
1781     char fmt[80];
1782     char *pbuf;
1783    
1784     size = GetFileVersionInfoSize(exefile, NULL);
1785     if (size == 0) {
1786     goto error;
1787     }
1788     buf = malloc(size);
1789     ZeroMemory(buf, size);
1790    
1791     if (GetFileVersionInfo(exefile, 0, size, buf) == FALSE) {
1792     goto error;
1793     }
1794    
1795     ret = VerQueryValue(buf,
1796     "\\VarFileInfo\\Translation",
1797     (LPVOID *)&lplgcode, &unLen);
1798     if (ret == FALSE)
1799     goto error;
1800    
1801     for (i = 0 ; i < (int)(unLen / sizeof(LANGANDCODEPAGE)) ; i++) {
1802 maya 2992 _snprintf_s(fmt, sizeof(fmt), _TRUNCATE,
1803 maya 3003 "\\StringFileInfo\\%04x%04x\\FileVersion",
1804     lplgcode[i].wLanguage, lplgcode[i].wCodePage);
1805 yutakakn 2792 VerQueryValue(buf, fmt, &pbuf, &unLen);
1806     if (unLen > 0) { // get success
1807     int n, a, b, c, d;
1808    
1809     n = sscanf(pbuf, "%d, %d, %d, %d", &a, &b, &c, &d);
1810     if (n == 4) { // convert success
1811     *major = a;
1812     *minor = b;
1813     *release = c;
1814     *build = d;
1815     break;
1816     }
1817     }
1818     }
1819    
1820     free(buf);
1821     return;
1822    
1823     error:
1824     free(buf);
1825     *major = *minor = *release = *build = 0;
1826     }
1827    
1828 yutakakn 2728 static void init_about_dlg(PTInstVar pvar, HWND dlg)
1829     {
1830     char buf[1024];
1831 yutakakn 2792 int a, b, c, d;
1832 maya 2994 char uimsg[MAX_UIMSG];
1833    
1834     GetWindowText(dlg, uimsg, sizeof(uimsg));
1835     UTIL_get_lang_msg("DLG_ABOUT_TITLE", pvar, uimsg);
1836 maya 2937 SetWindowText(dlg, pvar->ts->UIMsg);
1837 maya 2994 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1838     UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1839 maya 2937 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1840    
1841 yutakakn 2792 // TTSSH���o�[�W�������������� (2005.2.28 yutaka)
1842     get_file_version("ttxssh.dll", &a, &b, &c, &d);
1843 maya 2992 _snprintf_s(buf, sizeof(buf), _TRUNCATE,
1844 maya 3132 "TTSSH\r\nTera Term Secure Shell extension, %d.%d", a, b);
1845 yutakakn 2792 SendMessage(GetDlgItem(dlg, IDC_TTSSH_VERSION), WM_SETTEXT, 0, (LPARAM)buf);
1846    
1847 yutakakn 2782 // OpenSSL���o�[�W�������������� (2005.1.24 yutaka)
1848 yutakakn 2820 // ���������� (2005.5.11 yutaka)
1849     #ifdef OPENSSL_VERSION_TEXT
1850 yutakakn 2782 SendMessage(GetDlgItem(dlg, IDC_OPENSSL_VERSION), WM_SETTEXT, 0, (LPARAM)OPENSSL_VERSION_TEXT);
1851 yutakakn 2820 #else
1852     SendMessage(GetDlgItem(dlg, IDC_OPENSSL_VERSION), WM_SETTEXT, 0, (LPARAM)"Unknown");
1853     #endif
1854 yutakakn 2782
1855 yutakakn 2820 // zlib���o�[�W�������������� (2005.5.11 yutaka)
1856     #ifdef ZLIB_VERSION
1857 maya 2992 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "ZLib %s", ZLIB_VERSION);
1858 yutakakn 2820 #else
1859 yutakakn 2823 _snprintf(buf, sizeof(buf), "ZLib Unknown");
1860 yutakakn 2820 #endif
1861     SendMessage(GetDlgItem(dlg, IDC_ZLIB_VERSION), WM_SETTEXT, 0, (LPARAM)buf);
1862    
1863    
1864 yutakakn 2728 // TTSSH�_�C�A���O���\������SSH������������ (2004.10.30 yutaka)
1865     if (pvar->socket != INVALID_SOCKET) {
1866     if (SSHv1(pvar)) {
1867     SSH_get_server_ID_info(pvar, buf, sizeof(buf));
1868 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_SERVERID", pvar, "Server ID: ");
1869 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1870 yutakakn 2728 SSH_get_protocol_version_info(pvar, buf, sizeof(buf));
1871 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_PROTOCOL", pvar, "Using protocol: ");
1872 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1873 yutakakn 2728 CRYPT_get_cipher_info(pvar, buf, sizeof(buf));
1874 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_ENCRYPTION", pvar, "Encryption: ");
1875 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1876 yutakakn 2728 CRYPT_get_server_key_info(pvar, buf, sizeof(buf));
1877 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_SERVERKEY", pvar, "Server keys: ");
1878 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1879 yutakakn 2728 AUTH_get_auth_info(pvar, buf, sizeof(buf));
1880 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_AUTH", pvar, "Authentication: ");
1881 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1882 yutakakn 2728 SSH_get_compression_info(pvar, buf, sizeof(buf));
1883 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_COMP", pvar, "Compression: ");
1884 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1885 yutakakn 2728
1886     } else { // SSH2
1887     SSH_get_server_ID_info(pvar, buf, sizeof(buf));
1888 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_SERVERID", pvar, "Server ID: ");
1889 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1890 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_CLIENTID", pvar, "Client ID: ");
1891 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, pvar->client_version_string);
1892 yutakakn 2728
1893     SSH_get_protocol_version_info(pvar, buf, sizeof(buf));
1894 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_PROTOCOL", pvar, "Using protocol: ");
1895 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1896 yutakakn 2728
1897     if (pvar->kex_type == KEX_DH_GRP1_SHA1) {
1898 maya 2992 strncpy_s(buf, sizeof(buf), KEX_DH1, _TRUNCATE);
1899 yutakakn 2728 } else if (pvar->kex_type == KEX_DH_GRP14_SHA1) {
1900 maya 2992 strncpy_s(buf, sizeof(buf), KEX_DH14, _TRUNCATE);
1901 yutakakn 2728 } else {
1902 maya 2992 strncpy_s(buf, sizeof(buf), KEX_DHGEX, _TRUNCATE);
1903 yutakakn 2728 }
1904     append_about_text(dlg, "KEX: ", buf);
1905    
1906     if (pvar->hostkey_type == KEY_DSA) {
1907 maya 2992 strncpy_s(buf, sizeof(buf), "ssh-dss", _TRUNCATE);
1908 yutakakn 2728 } else {
1909 maya 2992 strncpy_s(buf, sizeof(buf), "ssh-rsa", _TRUNCATE);
1910 yutakakn 2728 }
1911 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_HOSTKEY", pvar, "Host Key: ");
1912 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1913 yutakakn 2728
1914 yutakakn 2758 // add HMAC algorithm (2004.12.17 yutaka)
1915     buf[0] = '\0';
1916     if (pvar->ctos_hmac == HMAC_SHA1) {
1917 maya 2992 strncat_s(buf, sizeof(buf), "hmac-sha1", _TRUNCATE);
1918 yutakakn 2758 } else if (pvar->ctos_hmac == HMAC_MD5) {
1919 maya 2992 strncat_s(buf, sizeof(buf), "hmac-md5", _TRUNCATE);
1920 yutakakn 2758 }
1921 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_TOSERVER", pvar, " to server, ");
1922 maya 2992 strncat_s(buf, sizeof(buf), pvar->ts->UIMsg, _TRUNCATE);
1923 yutakakn 2758 if (pvar->stoc_hmac == HMAC_SHA1) {
1924 maya 2992 strncat_s(buf, sizeof(buf), "hmac-sha1", _TRUNCATE);
1925 yutakakn 2758 } else if (pvar->stoc_hmac == HMAC_MD5) {
1926 maya 2992 strncat_s(buf, sizeof(buf), "hmac-md5", _TRUNCATE);
1927 yutakakn 2758 }
1928 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_FROMSERVER", pvar, " from server");
1929 maya 2992 strncat_s(buf, sizeof(buf), pvar->ts->UIMsg, _TRUNCATE);
1930 yutakakn 2758 append_about_text(dlg, "HMAC: ", buf);
1931    
1932 yutakakn 2728 CRYPT_get_cipher_info(pvar, buf, sizeof(buf));
1933 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_ENCRYPTION", pvar, "Encryption: ");
1934 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1935 yutakakn 2728 CRYPT_get_server_key_info(pvar, buf, sizeof(buf));
1936 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_SERVERKEY", pvar, "Server keys: ");
1937 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1938 maya 2994
1939 yutakakn 2728 AUTH_get_auth_info(pvar, buf, sizeof(buf));
1940 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_AUTH", pvar, "Authentication: ");
1941 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1942 yutakakn 2873
1943 yutakakn 2728 SSH_get_compression_info(pvar, buf, sizeof(buf));
1944 yutakakn 2873 if (pvar->ctos_compression == COMP_DELAYED) { // �x���p�P�b�g���k������ (2006.6.23 yutaka)
1945 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_COMPDELAY", pvar, "Delayed Compression: ");
1946 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1947 yutakakn 2873 } else {
1948 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_COMP", pvar, "Compression: ");
1949 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1950 yutakakn 2873 }
1951 yutakakn 2728 }
1952     }
1953     }
1954    
1955     static BOOL CALLBACK TTXAboutDlg(HWND dlg, UINT msg, WPARAM wParam,
1956 maya 3003 LPARAM lParam)
1957 yutakakn 2728 {
1958 maya 2937 LOGFONT logfont;
1959     HFONT font;
1960 maya 2994
1961 yutakakn 2728 switch (msg) {
1962     case WM_INITDIALOG:
1963 maya 2937 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1964     GetObject(font, sizeof(LOGFONT), &logfont);
1965 maya 2946 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAboutFont, pvar)) {
1966 maya 2937 SendDlgItemMessage(dlg, IDC_TTSSH_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1967     SendDlgItemMessage(dlg, IDC_SSHVERSIONS, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1968     SendDlgItemMessage(dlg, IDC_INCLUDES, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1969     SendDlgItemMessage(dlg, IDC_OPENSSL_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1970     SendDlgItemMessage(dlg, IDC_ZLIB_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1971     SendDlgItemMessage(dlg, IDC_WEBSITES, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1972     SendDlgItemMessage(dlg, IDC_CRYPTOGRAPHY, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1973     SendDlgItemMessage(dlg, IDC_CREDIT, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1974     SendDlgItemMessage(dlg, IDC_ABOUTTEXT, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1975     SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
1976     }
1977     else {
1978     DlgAboutFont = NULL;
1979     }
1980 maya 3139
1981     // �A�C�R�������I���Z�b�g
1982     {
1983     int fuLoad = LR_DEFAULTCOLOR;
1984     HICON hicon;
1985    
1986     if (is_NT4()) {
1987     fuLoad = LR_VGACOLOR;
1988     }
1989    
1990     hicon = LoadImage(hInst, MAKEINTRESOURCE(IDI_SECURETT),
1991     IMAGE_ICON, 32, 32, fuLoad);
1992     SendDlgItemMessage(dlg, IDC_TTSSH_ICON, STM_SETICON, (WPARAM)hicon, 0);
1993     }
1994    
1995 yutakakn 2728 init_about_dlg((PTInstVar) lParam, dlg);
1996     return TRUE;
1997     case WM_COMMAND:
1998     switch (LOWORD(wParam)) {
1999     case IDOK:
2000     EndDialog(dlg, 1);
2001 maya 2937 if (DlgAboutFont != NULL) {
2002     DeleteObject(DlgAboutFont);
2003     }
2004 yutakakn 2728 return TRUE;
2005     case IDCANCEL: /* there isn't a cancel button, but other Windows
2006     UI things can send this message */
2007     EndDialog(dlg, 0);
2008 maya 2937 if (DlgAboutFont != NULL) {
2009     DeleteObject(DlgAboutFont);
2010     }
2011 yutakakn 2728 return TRUE;
2012     }
2013     break;
2014     }
2015    
2016     return FALSE;
2017     }
2018    
2019     static char FAR *get_cipher_name(int cipher)
2020     {
2021     switch (cipher) {
2022     case SSH_CIPHER_NONE:
2023 maya 2994 UTIL_get_lang_msg("DLG_SSHSETUP_CIPHER_BORDER", pvar,
2024 maya 3003 "<ciphers below this line are disabled>");
2025 maya 2937 return pvar->ts->UIMsg;
2026 yutakakn 2728 case SSH_CIPHER_RC4:
2027 maya 3036 return "RC4(SSH1)";
2028 yutakakn 2728 case SSH_CIPHER_3DES:
2029 maya 3036 return "3DES(SSH1)";
2030 yutakakn 2728 case SSH_CIPHER_DES:
2031 maya 3036 return "DES(SSH1)";
2032 yutakakn 2728 case SSH_CIPHER_IDEA:
2033 maya 3036 return "IDEA(SSH1)";
2034 yutakakn 2728 case SSH_CIPHER_TSS:
2035 maya 3036 return "TSS(SSH1)";
2036 yutakakn 2728 case SSH_CIPHER_BLOWFISH:
2037 maya 3036 return "Blowfish(SSH1)";
2038 yutakakn 2728
2039     // for SSH2(yutaka)
2040 maya 3045 case SSH2_CIPHER_AES128:
2041 yutakakn 2728 return "AES128(SSH2)";
2042 maya 3045 case SSH2_CIPHER_AES192:
2043 maya 3040 return "AES192(SSH2)";
2044 maya 3045 case SSH2_CIPHER_AES256:
2045 maya 3036 return "AES256(SSH2)";
2046 maya 3045 case SSH2_CIPHER_3DES_CBC:
2047 yutakakn 2728 return "3DES-CBC(SSH2)";
2048 maya 3045 case SSH2_CIPHER_BLOWFISH:
2049     return "Blowfish(SSH2)";
2050 yutakakn 2728
2051     default:
2052     return NULL;
2053     }
2054     }
2055    
2056     static void set_move_button_status(HWND dlg)
2057     {
2058     HWND cipherControl = GetDlgItem(dlg, IDC_SSHCIPHERPREFS);
2059     int curPos = (int) SendMessage(cipherControl, LB_GETCURSEL, 0, 0);
2060     int maxPos = (int) SendMessage(cipherControl, LB_GETCOUNT, 0, 0) - 1;
2061    
2062 maya 3003 EnableWindow(GetDlgItem(dlg, IDC_SSHMOVECIPHERUP),
2063     curPos > 0 && curPos <= maxPos);
2064     EnableWindow(GetDlgItem(dlg, IDC_SSHMOVECIPHERDOWN),
2065     curPos >= 0 && curPos < maxPos);
2066 yutakakn 2728 }
2067    
2068     static void init_setup_dlg(PTInstVar pvar, HWND dlg)
2069     {
2070     HWND compressionControl = GetDlgItem(dlg, IDC_SSHCOMPRESSIONLEVEL);
2071     HWND cipherControl = GetDlgItem(dlg, IDC_SSHCIPHERPREFS);
2072     int i;
2073     int ch;
2074 maya 2994 char uimsg[MAX_UIMSG];
2075 maya 2937
2076 maya 2994 GetWindowText(dlg, uimsg, sizeof(uimsg));
2077     UTIL_get_lang_msg("DLG_SSHSETUP_TITLE", pvar, uimsg);
2078 maya 2937 SetWindowText(dlg, pvar->ts->UIMsg);
2079 maya 2994 GetDlgItemText(dlg, IDC_COMPRESSLABEL, uimsg, sizeof(uimsg));
2080     UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS", pvar, uimsg);
2081 maya 2937 SetDlgItemText(dlg, IDC_COMPRESSLABEL, pvar->ts->UIMsg);
2082 maya 2994 GetDlgItemText(dlg, IDC_COMPRESSNONE, uimsg, sizeof(uimsg));
2083     UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS_NONE", pvar, uimsg);
2084 maya 2937 SetDlgItemText(dlg, IDC_COMPRESSNONE, pvar->ts->UIMsg);
2085 maya 2994 GetDlgItemText(dlg, IDC_COMPRESSHIGH, uimsg, sizeof(uimsg));
2086     UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS_HIGHEST", pvar, uimsg);
2087 maya 2937 SetDlgItemText(dlg, IDC_COMPRESSHIGH, pvar->ts->UIMsg);
2088 maya 2994 GetDlgItemText(dlg, IDC_CIPHERORDER, uimsg, sizeof(uimsg));
2089     UTIL_get_lang_msg("DLG_SSHSETUP_CHIPER", pvar, uimsg);
2090 maya 2937 SetDlgItemText(dlg, IDC_CIPHERORDER, pvar->ts->UIMsg);
2091 maya 2994 GetDlgItemText(dlg, IDC_SSHMOVECIPHERUP, uimsg, sizeof(uimsg));
2092     UTIL_get_lang_msg("DLG_SSHSETUP_CHIPER_UP", pvar, uimsg);
2093 maya 2937 SetDlgItemText(dlg, IDC_SSHMOVECIPHERUP, pvar->ts->UIMsg);
2094 maya 2994 GetDlgItemText(dlg, IDC_SSHMOVECIPHERDOWN, uimsg, sizeof(uimsg));
2095     UTIL_get_lang_msg("DLG_SSHSETUP_CHIPER_DOWN", pvar, uimsg);
2096 maya 2937 SetDlgItemText(dlg, IDC_SSHMOVECIPHERDOWN, pvar->ts->UIMsg);
2097 maya 2994 GetDlgItemText(dlg, IDC_KNOWNHOSTS, uimsg, sizeof(uimsg));
2098     UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST", pvar, uimsg);
2099 maya 2937 SetDlgItemText(dlg, IDC_KNOWNHOSTS, pvar->ts->UIMsg);
2100 maya 2994 GetDlgItemText(dlg, IDC_CHOOSEREADWRITEFILE, uimsg, sizeof(uimsg));
2101     UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST_RW", pvar, uimsg);
2102 maya 2937 SetDlgItemText(dlg, IDC_CHOOSEREADWRITEFILE, pvar->ts->UIMsg);
2103 maya 2994 GetDlgItemText(dlg, IDC_CHOOSEREADONLYFILE, uimsg, sizeof(uimsg));
2104     UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST_RO", pvar, uimsg);
2105 maya 2937 SetDlgItemText(dlg, IDC_CHOOSEREADONLYFILE, pvar->ts->UIMsg);
2106 maya 2994 GetDlgItemText(dlg, IDC_HEARTBEATLABEL, uimsg, sizeof(uimsg));
2107     UTIL_get_lang_msg("DLG_SSHSETUP_HEARTBEAT", pvar, uimsg);
2108 maya 2937 SetDlgItemText(dlg, IDC_HEARTBEATLABEL, pvar->ts->UIMsg);
2109 maya 2994 GetDlgItemText(dlg, IDC_HEARTBEATLABEL2, uimsg, sizeof(uimsg));
2110     UTIL_get_lang_msg("DLG_SSHSETUP_HEARTBEAT_UNIT", pvar, uimsg);
2111 maya 2937 SetDlgItemText(dlg, IDC_HEARTBEATLABEL2, pvar->ts->UIMsg);
2112 maya 2994 GetDlgItemText(dlg, IDC_NOTICEBANNER, uimsg, sizeof(uimsg));
2113     UTIL_get_lang_msg("DLG_SSHSETUP_NOTICE", pvar, uimsg);
2114 maya 2937 SetDlgItemText(dlg, IDC_NOTICEBANNER, pvar->ts->UIMsg);
2115 maya 3002 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
2116 maya 2994 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
2117 maya 2937 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
2118 maya 3002 GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
2119 maya 2994 UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
2120 maya 2937 SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
2121    
2122 yutakakn 2728 SendMessage(compressionControl, TBM_SETRANGE, TRUE, MAKELONG(0, 9));
2123     SendMessage(compressionControl, TBM_SETPOS, TRUE,
2124 maya 3003 pvar->settings.CompressionLevel);
2125 yutakakn 2728
2126     normalize_cipher_order(pvar->settings