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