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