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 3179 - (hide annotations) (download) (as text)
Tue Dec 2 15:49:12 2008 UTC (15 years, 4 months ago) by maya
Original Path: ttssh2/trunk/ttxssh/ttxssh.c
File MIME type: text/x-csrc
File size: 121469 byte(s) 
/ssh-a オプションを追加
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 3179 } else if (_stricmp(option + 4, "-acceptall") == 0) {
1481     pvar->settings.LocalForwardingIdentityCheck = FALSE;
1482    
1483     // -axx������������������
1484     } else if (MATCH_STR(option + 4, "-a") == 0) {
1485     pvar->settings.ForwardAgent = FALSE;
1486 maya 3176 } else if (MATCH_STR(option + 4, "-A") == 0) {
1487     pvar->settings.ForwardAgent = TRUE;
1488    
1489 yutakakn 2728 } else if (MATCH_STR(option + 4, "-consume=") == 0) {
1490 maya 2911 read_ssh_options_from_user_file(pvar, option + 13);
1491 yutakakn 2728 DeleteFile(option + 13);
1492 maya 2907
1493     // /ssh1 �� /ssh2 �I�v�V�������V�K���� (2006.9.16 maya)
1494     } else if (MATCH_STR(option + 4, "1") == 0) {
1495 maya 3072 pvar->settings.Enabled = 1;
1496 maya 2907 pvar->settings.ssh_protocol_version = 1;
1497     } else if (MATCH_STR(option + 4, "2") == 0) {
1498 maya 3072 pvar->settings.Enabled = 1;
1499 maya 2907 pvar->settings.ssh_protocol_version = 2;
1500    
1501 yutakakn 2728 } else {
1502     char buf[1024];
1503    
1504 maya 2994 UTIL_get_lang_msg("MSG_UNKNOWN_OPTION_ERROR", pvar,
1505 maya 3003 "Unrecognized command-line option: %s");
1506 maya 2992 _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg, option);
1507 yutakakn 2728
1508     MessageBox(NULL, buf, "TTSSH", MB_OK | MB_ICONEXCLAMATION);
1509     }
1510    
1511 doda 3178 return OPTION_CLEAR;
1512 maya 2915
1513     // ttermpro.exe �� /T= �w�������p�������A������������ (2006.10.19 maya)
1514     } else if (MATCH_STR_I(option + 1, "t=") == 0) {
1515 yutakakn 2728 if (strcmp(option + 3, "2") == 0) {
1516     pvar->settings.Enabled = 1;
1517 doda 3178 return OPTION_CLEAR;
1518 yutakakn 2728 } else {
1519     pvar->settings.Enabled = 0;
1520     }
1521    
1522 maya 2915 // ttermpro.exe �� /F= �w������ TTSSH ������������ (2006.10.11 maya)
1523     } else if (MATCH_STR_I(option + 1, "f=") == 0) {
1524 maya 2913 read_ssh_options_from_user_file(pvar, option + 3);
1525    
1526 yutakakn 2728 // /1 ������ /2 �I�v�V�������V�K���� (2004.10.3 yutaka)
1527     } else if (MATCH_STR(option + 1, "1") == 0) {
1528     // command line: /ssh /1 is SSH1 only
1529     pvar->settings.ssh_protocol_version = 1;
1530    
1531     } else if (MATCH_STR(option + 1, "2") == 0) {
1532     // command line: /ssh /2 is SSH2 & SSH1
1533     pvar->settings.ssh_protocol_version = 2;
1534    
1535     } else if (MATCH_STR(option + 1, "nossh") == 0) {
1536     // '/nossh' �I�v�V�����������B
1537     // TERATERM.INI ��SSH���L�������������������A������Cygterm���N��������������
1538     // �����������������B(2004.10.11 yutaka)
1539     pvar->settings.Enabled = 0;
1540    
1541 maya 2907 } else if (MATCH_STR(option + 1, "telnet") == 0) {
1542     // '/telnet' ���w�������������������� '/nossh' ��������
1543     // SSH������������ (2006.9.16 maya)
1544     pvar->settings.Enabled = 0;
1545    
1546 yutakakn 2739 } else if (MATCH_STR(option + 1, "auth") == 0) {
1547 yutakakn 2784 // SSH2�������O�C���I�v�V����������
1548 yutakakn 2739 //
1549 yutakakn 2784 // SYNOPSIS: /ssh /auth=passowrd /user=���[�U�� /passwd=�p�X���[�h
1550     // /ssh /auth=publickey /user=���[�U�� /passwd=�p�X���[�h /keyfile=�p�X
1551     // EXAMPLE: /ssh /auth=password /user=nike /passwd=a@bc
1552     // /ssh /auth=publickey /user=foo /passwd=bar /keyfile=d:\tmp\id_rsa
1553     // NOTICE: �p�X���[�h���p�X�������������������A�u�����N���������� @ ���g�������B
1554 yutakakn 2739 //
1555 yutakakn 2784 // (2004.11.30 yutaka)
1556     // (2005.1.26 yutaka) ���������B���J���F���T�|�[�g�B
1557     //
1558 yutakakn 2739 pvar->ssh2_autologin = 1; // for SSH2 (2004.11.30 yutaka)
1559    
1560 maya 3025 if (MATCH_STR(option + 5, "=password") == 0) { // �p�X���[�h
1561 yutakakn 2784 //pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
1562     pvar->ssh2_authmethod = SSH_AUTH_PASSWORD;
1563 yutakakn 2739
1564 maya 3028 // /auth=challenge ������ (2007.10.5 maya)
1565     } else if (MATCH_STR(option + 5, "=challenge") == 0) { // keyboard-interactive�F��
1566 maya 3025 //pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
1567     pvar->ssh2_authmethod = SSH_AUTH_TIS;
1568    
1569 yutakakn 2784 } else if (MATCH_STR(option + 5, "=publickey") == 0) { // ���J���F��
1570     //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1571     pvar->ssh2_authmethod = SSH_AUTH_RSA;
1572    
1573 maya 3108 } else if (MATCH_STR(option + 5, "=pageant") == 0) { // ���J���F�� by Pageant
1574     //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1575     pvar->ssh2_authmethod = SSH_AUTH_PAGEANT;
1576    
1577 yutakakn 2739 } else {
1578     // TODO:
1579    
1580     }
1581    
1582     } else if (MATCH_STR(option + 1, "user=") == 0) {
1583 yutakakn 2784 replace_to_blank(option + 6, pvar->ssh2_username, sizeof(pvar->ssh2_username));
1584     //_snprintf(pvar->ssh2_username, sizeof(pvar->ssh2_username), "%s", option + 6);
1585 yutakakn 2739
1586     } else if (MATCH_STR(option + 1, "passwd=") == 0) {
1587 yutakakn 2784 replace_to_blank(option + 8, pvar->ssh2_password, sizeof(pvar->ssh2_password));
1588     //_snprintf(pvar->ssh2_password, sizeof(pvar->ssh2_password), "%s", option + 8);
1589 yutakakn 2739
1590 yutakakn 2784 } else if (MATCH_STR(option + 1, "keyfile=") == 0) {
1591     replace_to_blank(option + 9, pvar->ssh2_keyfile, sizeof(pvar->ssh2_keyfile));
1592    
1593 maya 2908 } else if (MATCH_STR(option + 1, "ask4passwd") == 0) {
1594     // �p�X���[�h������ (2006.9.18 maya)
1595     pvar->ask4passwd = 1;
1596    
1597 yutakakn 2728 }
1598    
1599 maya 2908 // �p�X���[�h�������������������O�C��������������
1600     // /auth ���F�����\�b�h���w�������������p������ (2006.9.18 maya)
1601     if (pvar->ask4passwd == 1) {
1602     pvar->ssh2_autologin = 0;
1603     }
1604    
1605 yutakakn 2728 }
1606 doda 3178 else if ((MATCH_STR_I(option, "ssh://") == 0) ||
1607     (MATCH_STR_I(option, "ssh1://") == 0) ||
1608     (MATCH_STR_I(option, "ssh2://") == 0) ||
1609     (MATCH_STR_I(option, "slogin://") == 0) ||
1610     (MATCH_STR_I(option, "slogin1://") == 0) ||
1611     (MATCH_STR_I(option, "slogin2://") == 0)) {
1612 yutakakn 2728
1613 doda 3178 char *p, *p2, *p3;
1614     int optlen;
1615    
1616     p = strchr(option, ':');
1617     optlen = strlen(option);
1618    
1619     switch (*(p-1)) {
1620     case '1':
1621     pvar->settings.ssh_protocol_version = 1;
1622     break;
1623     case '2':
1624     pvar->settings.ssh_protocol_version = 2;
1625     break;
1626     }
1627    
1628     p += 3;
1629     memset(option, ' ', p - option);
1630    
1631     if ((p2 = strchr(p, '/')) != NULL) {
1632     memset(p2, ' ', strlen(option) - (p2 - option));
1633     }
1634    
1635     if ((p2 = strchr(p, '@')) != NULL) {
1636     *p2 = 0;
1637     if ((p3 = strchr(p, ':')) != NULL) {
1638     *p3 = 0;
1639     strcpy_s(pvar->ssh2_password, sizeof(pvar->ssh2_password), p3 + 1);
1640     pvar->ssh2_autologin = 1;
1641     }
1642     strcpy_s(pvar->ssh2_username, sizeof(pvar->ssh2_username), p);
1643     memset(p, ' ', (p2 - p) + 1);
1644     }
1645    
1646     pvar->settings.Enabled = 1;
1647    
1648     return OPTION_REPLACE;
1649     }
1650    
1651     return OPTION_NONE;
1652 yutakakn 2728 }
1653    
1654     static void FAR PASCAL TTXParseParam(PCHAR param, PTTSet ts,
1655 maya 3003 PCHAR DDETopic)
1656 yutakakn 2728 {
1657 maya 2911 // �X�y�[�X�������t�@�C�������F�������������C�� (2006.10.7 maya)
1658 doda 3178 int i, buflen;
1659 yutakakn 2728 BOOL inParam = FALSE;
1660     BOOL inQuotes = FALSE;
1661 maya 2911 BOOL inFileParam = FALSE;
1662 yutakakn 2728 PCHAR option = NULL;
1663    
1664     if (pvar->hostdlg_activated) {
1665     pvar->settings.Enabled = pvar->hostdlg_Enabled;
1666     }
1667    
1668     for (i = 0; param[i] != 0; i++) {
1669 maya 2911 if (inQuotes ? param[i] == '"'
1670 maya 3003 : (param[i] == ' ' || param[i] == '\t')) {
1671 yutakakn 2728 if (option != NULL) {
1672     char ch = param[i];
1673 maya 2911 PCHAR Equal;
1674 yutakakn 2728
1675     param[i] = 0;
1676 maya 2911 Equal = strchr(option, '=');
1677     if (inFileParam && Equal != NULL && *(Equal + 1) == '"') {
1678 maya 2992 int buf_len = strlen(option) * sizeof(char);
1679 maya 2911 char *buf = (char *)calloc(strlen(option), sizeof(char));
1680 maya 2992 char c = option[Equal - option + 1];
1681     option[Equal - option + 1] = 0;
1682     strncat_s(buf, buf_len, option, _TRUNCATE);
1683     option[Equal - option + 1] = c;
1684     strncat_s(buf, buf_len, Equal + 2, _TRUNCATE);
1685 doda 3178 switch (parse_option(pvar, *buf == '"' ? buf + 1 : buf)) {
1686     case OPTION_CLEAR:
1687 maya 2911 memset(option, ' ', i + 1 - (option - param));
1688 doda 3178 break;
1689     case OPTION_REPLACE:
1690     buflen = strlen(buf);
1691     memcpy(option, buf, buflen);
1692     memset(option + buflen, ' ', i + 1 - buflen - (option - param));
1693     break;
1694     default:
1695 maya 2911 param[i] = ch;
1696     }
1697     free(buf);
1698 yutakakn 2728 }
1699 maya 2911 else {
1700 doda 3178 switch (parse_option(pvar, *option == '"' ? option + 1 : option)) {
1701     case OPTION_CLEAR:
1702 maya 2911 memset(option, ' ', i + 1 - (option - param));
1703 doda 3178 break;
1704     default:
1705 maya 2911 param[i] = ch;
1706     }
1707     }
1708 yutakakn 2728 option = NULL;
1709     }
1710     inParam = FALSE;
1711     inQuotes = FALSE;
1712 maya 2911 inFileParam = FALSE;
1713 yutakakn 2728 } else if (!inParam) {
1714     if (param[i] == '"') {
1715     inQuotes = TRUE;
1716     inParam = TRUE;
1717     option = param + i;
1718     } else if (param[i] != ' ' && param[i] != '\t') {
1719     inParam = TRUE;
1720     option = param + i;
1721     }
1722 maya 2911 } else {
1723     if (option == NULL) {
1724     continue;
1725     }
1726     if ((option[0] == '-' || option[0] == '/') &&
1727 maya 3003 (MATCH_STR(option + 1, "ssh-f=") == 0 ||
1728     MATCH_STR(option + 1, "ssh-consume=") == 0 ||
1729     MATCH_STR_I(option + 1, "f=") == 0 ||
1730     MATCH_STR(option + 1, "keyfile=") == 0)) {
1731 maya 2911 if (param[i] == '"') {
1732     inQuotes = TRUE;
1733     }
1734     inFileParam = TRUE;
1735     }
1736 yutakakn 2728 }
1737     }
1738    
1739     if (option != NULL) {
1740 maya 2911 PCHAR Equal = strchr(option, '=');
1741     if (inFileParam && Equal != NULL && *(Equal + 1) == '"') {
1742 maya 2992 int buf_len = strlen(option) * sizeof(char);
1743 maya 2911 char *buf = (char *)calloc(strlen(option), sizeof(char));
1744 maya 2992 char c = option[Equal - option + 1];
1745     option[Equal - option + 1] = 0;
1746     strncat_s(buf, buf_len, option, _TRUNCATE);
1747     option[Equal - option + 1] = c;
1748     strncat_s(buf, buf_len, Equal + 2, _TRUNCATE);
1749 doda 3178 switch (parse_option(pvar, *buf == '"' ? buf + 1 : buf)) {
1750     case OPTION_CLEAR:
1751 maya 2911 memset(option, ' ', i + 1 - (option - param));
1752 doda 3178 break;
1753     case OPTION_REPLACE:
1754     strcpy_s(option, i - (param - option), buf);
1755     break;
1756 maya 2911 }
1757     free(buf);
1758 yutakakn 2728 }
1759 maya 2911 else {
1760 doda 3178 switch (parse_option(pvar, option)) {
1761     case OPTION_CLEAR:
1762 maya 2911 memset(option, ' ', i - (option - param));
1763 doda 3178 break;
1764 maya 2911 }
1765     }
1766 yutakakn 2728 }
1767    
1768     FWDUI_load_settings(pvar);
1769    
1770     (pvar->ParseParam) (param, ts, DDETopic);
1771    
1772     }
1773    
1774     static void PASCAL FAR TTXGetSetupHooks(TTXSetupHooks FAR * hooks)
1775     {
1776     pvar->ReadIniFile = *hooks->ReadIniFile;
1777     pvar->WriteIniFile = *hooks->WriteIniFile;
1778     pvar->ParseParam = *hooks->ParseParam;
1779    
1780     *hooks->ReadIniFile = TTXReadINIFile;
1781     *hooks->WriteIniFile = TTXWriteINIFile;
1782     *hooks->ParseParam = TTXParseParam;
1783     }
1784    
1785     static void PASCAL FAR TTXSetWinSize(int rows, int cols)
1786     {
1787     SSH_notify_win_size(pvar, cols, rows);
1788     }
1789    
1790     static void insertMenuBeforeItem(HMENU menu, WORD beforeItemID, WORD flags,
1791 maya 3003 WORD newItemID, char FAR * text)
1792 yutakakn 2728 {
1793     int i, j;
1794    
1795     for (i = GetMenuItemCount(menu) - 1; i >= 0; i--) {
1796     HMENU submenu = GetSubMenu(menu, i);
1797    
1798     for (j = GetMenuItemCount(submenu) - 1; j >= 0; j--) {
1799     if (GetMenuItemID(submenu, j) == beforeItemID) {
1800 maya 3003 InsertMenu(submenu, j, MF_BYPOSITION | flags, newItemID, text);
1801 yutakakn 2728 return;
1802     }
1803     }
1804     }
1805     }
1806    
1807     static void PASCAL FAR TTXModifyMenu(HMENU menu)
1808     {
1809     /* inserts before ID_HELP_ABOUT */
1810 maya 2994 UTIL_get_lang_msg("MENU_ABOUT", pvar, "About &TTSSH...");
1811 maya 2937 insertMenuBeforeItem(menu, 50990, MF_ENABLED, ID_ABOUTMENU, pvar->ts->UIMsg);
1812 yutakakn 2728
1813     /* inserts before ID_SETUP_TCPIP */
1814 maya 2994 UTIL_get_lang_msg("MENU_SSH", pvar, "SS&H...");
1815 maya 2937 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHSETUPMENU, pvar->ts->UIMsg);
1816 yutakakn 2728 /* inserts before ID_SETUP_TCPIP */
1817 maya 2994 UTIL_get_lang_msg("MENU_SSH_AUTH", pvar, "SSH &Authentication...");
1818 maya 2937 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHAUTHSETUPMENU, pvar->ts->UIMsg);
1819 yutakakn 2728 /* inserts before ID_SETUP_TCPIP */
1820 maya 2994 UTIL_get_lang_msg("MENU_SSH_FORWARD", pvar, "SSH F&orwarding...");
1821 maya 2937 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHFWDSETUPMENU, pvar->ts->UIMsg);
1822 maya 2994 UTIL_get_lang_msg("MENU_SSH_KEYGEN", pvar, "SSH KeyGe&nerator...");
1823 maya 2937 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHKEYGENMENU, pvar->ts->UIMsg);
1824 yutakapon 3074
1825     /* inserts before ID_FILE_CHANGEDIR */
1826     UTIL_get_lang_msg("MENU_SSH_SCP", pvar, "SSH SCP...");
1827     insertMenuBeforeItem(menu, 50170, MF_ENABLED, ID_SSHSCPMENU, pvar->ts->UIMsg);
1828 yutakakn 2728 }
1829    
1830     static void append_about_text(HWND dlg, char FAR * prefix, char FAR * msg)
1831     {
1832     SendDlgItemMessage(dlg, IDC_ABOUTTEXT, EM_REPLACESEL, 0,
1833 maya 3003 (LPARAM) prefix);
1834 yutakakn 2728 SendDlgItemMessage(dlg, IDC_ABOUTTEXT, EM_REPLACESEL, 0, (LPARAM) msg);
1835     SendDlgItemMessage(dlg, IDC_ABOUTTEXT, EM_REPLACESEL, 0,
1836 maya 3003 (LPARAM) (char FAR *) "\r\n");
1837 yutakakn 2728 }
1838    
1839 yutakakn 2792 // ���s�t�@�C�������o�[�W�������������� (2005.2.28 yutaka)
1840 yutakakn 2793 void get_file_version(char *exefile, int *major, int *minor, int *release, int *build)
1841 yutakakn 2792 {
1842     typedef struct {
1843     WORD wLanguage;
1844     WORD wCodePage;
1845     } LANGANDCODEPAGE, *LPLANGANDCODEPAGE;
1846     LPLANGANDCODEPAGE lplgcode;
1847     UINT unLen;
1848     DWORD size;
1849     char *buf = NULL;
1850     BOOL ret;
1851     int i;
1852     char fmt[80];
1853     char *pbuf;
1854    
1855     size = GetFileVersionInfoSize(exefile, NULL);
1856     if (size == 0) {
1857     goto error;
1858     }
1859     buf = malloc(size);
1860     ZeroMemory(buf, size);
1861    
1862     if (GetFileVersionInfo(exefile, 0, size, buf) == FALSE) {
1863     goto error;
1864     }
1865    
1866     ret = VerQueryValue(buf,
1867     "\\VarFileInfo\\Translation",
1868     (LPVOID *)&lplgcode, &unLen);
1869     if (ret == FALSE)
1870     goto error;
1871    
1872     for (i = 0 ; i < (int)(unLen / sizeof(LANGANDCODEPAGE)) ; i++) {
1873 maya 2992 _snprintf_s(fmt, sizeof(fmt), _TRUNCATE,
1874 maya 3003 "\\StringFileInfo\\%04x%04x\\FileVersion",
1875     lplgcode[i].wLanguage, lplgcode[i].wCodePage);
1876 yutakakn 2792 VerQueryValue(buf, fmt, &pbuf, &unLen);
1877     if (unLen > 0) { // get success
1878     int n, a, b, c, d;
1879    
1880     n = sscanf(pbuf, "%d, %d, %d, %d", &a, &b, &c, &d);
1881     if (n == 4) { // convert success
1882     *major = a;
1883     *minor = b;
1884     *release = c;
1885     *build = d;
1886     break;
1887     }
1888     }
1889     }
1890    
1891     free(buf);
1892     return;
1893    
1894     error:
1895     free(buf);
1896     *major = *minor = *release = *build = 0;
1897     }
1898    
1899 yutakakn 2728 static void init_about_dlg(PTInstVar pvar, HWND dlg)
1900     {
1901     char buf[1024];
1902 yutakakn 2792 int a, b, c, d;
1903 maya 2994 char uimsg[MAX_UIMSG];
1904    
1905     GetWindowText(dlg, uimsg, sizeof(uimsg));
1906     UTIL_get_lang_msg("DLG_ABOUT_TITLE", pvar, uimsg);
1907 maya 2937 SetWindowText(dlg, pvar->ts->UIMsg);
1908 maya 2994 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1909     UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1910 maya 2937 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1911    
1912 yutakakn 2792 // TTSSH���o�[�W�������������� (2005.2.28 yutaka)
1913     get_file_version("ttxssh.dll", &a, &b, &c, &d);
1914 maya 2992 _snprintf_s(buf, sizeof(buf), _TRUNCATE,
1915 maya 3132 "TTSSH\r\nTera Term Secure Shell extension, %d.%d", a, b);
1916 yutakakn 2792 SendMessage(GetDlgItem(dlg, IDC_TTSSH_VERSION), WM_SETTEXT, 0, (LPARAM)buf);
1917    
1918 yutakakn 2782 // OpenSSL���o�[�W�������������� (2005.1.24 yutaka)
1919 yutakakn 2820 // ���������� (2005.5.11 yutaka)
1920     #ifdef OPENSSL_VERSION_TEXT
1921 yutakakn 2782 SendMessage(GetDlgItem(dlg, IDC_OPENSSL_VERSION), WM_SETTEXT, 0, (LPARAM)OPENSSL_VERSION_TEXT);
1922 yutakakn 2820 #else
1923     SendMessage(GetDlgItem(dlg, IDC_OPENSSL_VERSION), WM_SETTEXT, 0, (LPARAM)"Unknown");
1924     #endif
1925 yutakakn 2782
1926 yutakakn 2820 // zlib���o�[�W�������������� (2005.5.11 yutaka)
1927     #ifdef ZLIB_VERSION
1928 maya 2992 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "ZLib %s", ZLIB_VERSION);
1929 yutakakn 2820 #else
1930 yutakakn 2823 _snprintf(buf, sizeof(buf), "ZLib Unknown");
1931 yutakakn 2820 #endif
1932     SendMessage(GetDlgItem(dlg, IDC_ZLIB_VERSION), WM_SETTEXT, 0, (LPARAM)buf);
1933    
1934    
1935 yutakakn 2728 // TTSSH�_�C�A���O���\������SSH������������ (2004.10.30 yutaka)
1936     if (pvar->socket != INVALID_SOCKET) {
1937     if (SSHv1(pvar)) {
1938     SSH_get_server_ID_info(pvar, buf, sizeof(buf));
1939 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_SERVERID", pvar, "Server ID: ");
1940 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1941 yutakakn 2728 SSH_get_protocol_version_info(pvar, buf, sizeof(buf));
1942 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_PROTOCOL", pvar, "Using protocol: ");
1943 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1944 yutakakn 2728 CRYPT_get_cipher_info(pvar, buf, sizeof(buf));
1945 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_ENCRYPTION", pvar, "Encryption: ");
1946 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1947 yutakakn 2728 CRYPT_get_server_key_info(pvar, buf, sizeof(buf));
1948 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_SERVERKEY", pvar, "Server keys: ");
1949 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1950 yutakakn 2728 AUTH_get_auth_info(pvar, buf, sizeof(buf));
1951 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_AUTH", pvar, "Authentication: ");
1952 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1953 yutakakn 2728 SSH_get_compression_info(pvar, buf, sizeof(buf));
1954 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_COMP", pvar, "Compression: ");
1955 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1956 yutakakn 2728
1957     } else { // SSH2
1958     SSH_get_server_ID_info(pvar, buf, sizeof(buf));
1959 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_SERVERID", pvar, "Server ID: ");
1960 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1961 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_CLIENTID", pvar, "Client ID: ");
1962 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, pvar->client_version_string);
1963 yutakakn 2728
1964     SSH_get_protocol_version_info(pvar, buf, sizeof(buf));
1965 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_PROTOCOL", pvar, "Using protocol: ");
1966 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1967 yutakakn 2728
1968     if (pvar->kex_type == KEX_DH_GRP1_SHA1) {
1969 maya 2992 strncpy_s(buf, sizeof(buf), KEX_DH1, _TRUNCATE);
1970 yutakakn 2728 } else if (pvar->kex_type == KEX_DH_GRP14_SHA1) {
1971 maya 2992 strncpy_s(buf, sizeof(buf), KEX_DH14, _TRUNCATE);
1972 yutakakn 2728 } else {
1973 maya 2992 strncpy_s(buf, sizeof(buf), KEX_DHGEX, _TRUNCATE);
1974 yutakakn 2728 }
1975     append_about_text(dlg, "KEX: ", buf);
1976    
1977     if (pvar->hostkey_type == KEY_DSA) {
1978 maya 2992 strncpy_s(buf, sizeof(buf), "ssh-dss", _TRUNCATE);
1979 yutakakn 2728 } else {
1980 maya 2992 strncpy_s(buf, sizeof(buf), "ssh-rsa", _TRUNCATE);
1981 yutakakn 2728 }
1982 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_HOSTKEY", pvar, "Host Key: ");
1983 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
1984 yutakakn 2728
1985 yutakakn 2758 // add HMAC algorithm (2004.12.17 yutaka)
1986     buf[0] = '\0';
1987     if (pvar->ctos_hmac == HMAC_SHA1) {
1988 maya 2992 strncat_s(buf, sizeof(buf), "hmac-sha1", _TRUNCATE);
1989 yutakakn 2758 } else if (pvar->ctos_hmac == HMAC_MD5) {
1990 maya 2992 strncat_s(buf, sizeof(buf), "hmac-md5", _TRUNCATE);
1991 yutakakn 2758 }
1992 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_TOSERVER", pvar, " to server, ");
1993 maya 2992 strncat_s(buf, sizeof(buf), pvar->ts->UIMsg, _TRUNCATE);
1994 yutakakn 2758 if (pvar->stoc_hmac == HMAC_SHA1) {
1995 maya 2992 strncat_s(buf, sizeof(buf), "hmac-sha1", _TRUNCATE);
1996 yutakakn 2758 } else if (pvar->stoc_hmac == HMAC_MD5) {
1997 maya 2992 strncat_s(buf, sizeof(buf), "hmac-md5", _TRUNCATE);
1998 yutakakn 2758 }
1999 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_FROMSERVER", pvar, " from server");
2000 maya 2992 strncat_s(buf, sizeof(buf), pvar->ts->UIMsg, _TRUNCATE);
2001 yutakakn 2758 append_about_text(dlg, "HMAC: ", buf);
2002    
2003 yutakakn 2728 CRYPT_get_cipher_info(pvar, buf, sizeof(buf));
2004 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_ENCRYPTION", pvar, "Encryption: ");
2005 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
2006 yutakakn 2728 CRYPT_get_server_key_info(pvar, buf, sizeof(buf));
2007 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_SERVERKEY", pvar, "Server keys: ");
2008 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
2009 maya 2994
2010 yutakakn 2728 AUTH_get_auth_info(pvar, buf, sizeof(buf));
2011 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_AUTH", pvar, "Authentication: ");
2012 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
2013 yutakakn 2873
2014 yutakakn 2728 SSH_get_compression_info(pvar, buf, sizeof(buf));
2015 yutakakn 2873 if (pvar->ctos_compression == COMP_DELAYED) { // �x���p�P�b�g���k������ (2006.6.23 yutaka)
2016 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_COMPDELAY", pvar, "Delayed Compression: ");
2017 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
2018 yutakakn 2873 } else {
2019 maya 2994 UTIL_get_lang_msg("DLG_ABOUT_COMP", pvar, "Compression: ");
2020 maya 2949 append_about_text(dlg, pvar->ts->UIMsg, buf);
2021 yutakakn 2873 }
2022 yutakakn 2728 }
2023     }
2024     }
2025    
2026     static BOOL CALLBACK TTXAboutDlg(HWND dlg, UINT msg, WPARAM wParam,
2027 maya 3003 LPARAM lParam)
2028 yutakakn 2728 {
2029 maya 2937 LOGFONT logfont;
2030     HFONT font;
2031 maya 2994
2032 yutakakn 2728 switch (msg) {
2033     case WM_INITDIALOG:
2034 maya 2937 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
2035     GetObject(font, sizeof(LOGFONT), &logfont);
2036 maya 2946 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAboutFont, pvar)) {
2037 maya 2937 SendDlgItemMessage(dlg, IDC_TTSSH_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2038     SendDlgItemMessage(dlg, IDC_SSHVERSIONS, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2039     SendDlgItemMessage(dlg, IDC_INCLUDES, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2040     SendDlgItemMessage(dlg, IDC_OPENSSL_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2041     SendDlgItemMessage(dlg, IDC_ZLIB_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2042     SendDlgItemMessage(dlg, IDC_WEBSITES, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2043     SendDlgItemMessage(dlg, IDC_CRYPTOGRAPHY, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2044     SendDlgItemMessage(dlg, IDC_CREDIT, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2045     SendDlgItemMessage(dlg, IDC_ABOUTTEXT, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2046     SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2047     }
2048     else {
2049     DlgAboutFont = NULL;
2050     }
2051 maya 3139
2052     // �A�C�R�������I���Z�b�g
2053     {
2054     int fuLoad = LR_DEFAULTCOLOR;
2055     HICON hicon;
2056    
2057     if (is_NT4()) {
2058     fuLoad = LR_VGACOLOR;
2059     }
2060    
2061     hicon = LoadImage(hInst, MAKEINTRESOURCE(IDI_SECURETT),
2062     IMAGE_ICON, 32, 32, fuLoad);
2063     SendDlgItemMessage(dlg, IDC_TTSSH_ICON, STM_SETICON, (WPARAM)hicon, 0);
2064     }
2065    
2066 yutakakn 2728 init_about_dlg((PTInstVar) lParam, dlg);
2067     return TRUE;
2068     case WM_COMMAND:
2069     switch (LOWORD(wParam)) {
2070     case IDOK:
2071     EndDialog(dlg, 1);
2072 maya 2937 if (DlgAboutFont != NULL) {
2073     DeleteObject(DlgAboutFont);
2074     }
2075 yutakakn 2728 return TRUE;
2076     case IDCANCEL: /* there isn't a cancel button, but other Windows
2077     UI things can send this message */
2078     EndDialog(dlg, 0);
2079 maya 2937 if (DlgAboutFont != NULL) {
2080     DeleteObject(DlgAboutFont);
2081     }
2082 yutakakn 2728 return TRUE;
2083     }
2084     break;
2085     }
2086    
2087     return FALSE;
2088     }
2089    
2090     static char FAR *get_cipher_name(int cipher)
2091     {
2092     switch (cipher) {
2093     case SSH_CIPHER_NONE:
2094 maya 2994 UTIL_get_lang_msg("DLG_SSHSETUP_CIPHER_BORDER", pvar,
2095 maya 3003 "<ciphers below this line are disabled>");
2096 maya 2937 return pvar->ts->UIMsg;
2097 yutakakn 2728 case SSH_CIPHER_RC4:
2098 maya 3036 return "RC4(SSH1)";
2099 yutakakn 2728 case SSH_CIPHER_3DES:
2100 maya 3036 return "3DES(SSH1)";
2101 yutakakn 2728 case SSH_CIPHER_DES:
2102 maya 3036 return "DES(SSH1)";
2103 yutakakn 2728 case SSH_CIPHER_IDEA:
2104 maya 3036 return "IDEA(SSH1)";
2105 yutakakn 2728 case SSH_CIPHER_TSS:
2106 maya 3036 return "TSS(SSH1)";
2107 yutakakn 2728 case SSH_CIPHER_BLOWFISH:
2108 maya 3036 return "Blowfish(SSH1)";
2109 yutakakn 2728
2110     // for SSH2(yutaka)
2111 maya 3157 case SSH2_CIPHER_AES128_CBC:
2112     return "AES128-CBC(SSH2)";
2113     case SSH2_CIPHER_AES192_CBC:
2114     return "AES192-CBC(SSH2)";
2115     case SSH2_CIPHER_AES256_CBC:
2116     return "AES256-CBC(SSH2)";
2117 maya 3045 case SSH2_CIPHER_3DES_CBC:
2118 yutakakn 2728 return "3DES-CBC(SSH2)";
2119 maya 3157 case SSH2_CIPHER_BLOWFISH_CBC:
2120     return "Blowfish-CBC(SSH2)";
2121 maya 3159 case SSH2_CIPHER_AES128_CTR:
2122     return "AES128-CTR(SSH2)";
2123     case SSH2_CIPHER_AES192_CTR:
2124     return "AES192-CTR(SSH2)";
2125     case SSH2_CIPHER_AES256_CTR:
2126     return "AES256-CTR(SSH2)";
2127 doda 3168 case SSH2_CIPHER_ARCFOUR:
2128     return "Arcfour(SSH2)";
2129 doda 3169 case SSH2_CIPHER_ARCFOUR128:
2130     return "Arcfour128(SSH2)";
2131     case SSH2_CIPHER_ARCFOUR256:
2132     return "Arcfour256(SSH2)";
2133 maya 3170 case SSH2_CIPHER_CAST128_CBC: