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