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

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