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