Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/ttssh2/ttxssh/pkt.c

Diff of /trunk/ttssh2/ttxssh/pkt.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

ttssh2/trunk/ttxssh/pkt.c revision 2729 by yutakakn, Sun Nov 14 15:53:21 2004 UTC trunk/ttssh2/ttxssh/pkt.c revision 6841 by doda, Tue Jul 4 15:02:28 2017 UTC
# Line 1  Line 1 
1  /*  /*
2  Copyright (c) 1998-2001, Robert O'Callahan   * Copyright (c) 1998-2001, Robert O'Callahan
3  All rights reserved.   * (C) 2004-2017 TeraTerm Project
4     * All rights reserved.
5  Redistribution and use in source and binary forms, with or without modification,   *
6  are permitted provided that the following conditions are met:   * Redistribution and use in source and binary forms, with or without
7     * modification, are permitted provided that the following conditions
8  Redistributions of source code must retain the above copyright notice, this list of   * are met:
9  conditions and the following disclaimer.   *
10     * 1. Redistributions of source code must retain the above copyright
11  Redistributions in binary form must reproduce the above copyright notice, this list   *    notice, this list of conditions and the following disclaimer.
12  of conditions and the following disclaimer in the documentation and/or other materials   * 2. Redistributions in binary form must reproduce the above copyright
13  provided with the distribution.   *    notice, this list of conditions and the following disclaimer in the
14     *    documentation and/or other materials provided with the distribution.
15  The name of Robert O'Callahan may not be used to endorse or promote products derived from   * 3. The name of the author may not be used to endorse or promote products
16  this software without specific prior written permission.   *    derived from this software without specific prior written permission.
17     *
18  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND   * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
19  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES   * 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   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21  THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,   * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF   * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)   * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS   * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  */   * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28     */
29  /*  
30  This code is copyright (C) 1998-1999 Robert O'Callahan.  /*
31  See LICENSE.TXT for the license.  This code is copyright (C) 1998-1999 Robert O'Callahan.
32  */  See LICENSE.TXT for the license.
33    */
34  #include "ttxssh.h"  
35  #include "util.h"  #include "ttxssh.h"
36    #include "util.h"
37  //#define READAMOUNT 60000  #include "pkt.h"
38  // 60000 -> 65536 へ拡張。SSH2ではwindow制御を行うため、SSH2のwindow sizeと  
39  // 合わせておく必要がある。(2004.10.17 yutaka)  //#define READAMOUNT 60000
40  #define READAMOUNT 65536  // 60000 -> 65536 へ拡張。SSH2ではwindow制御を行うため、SSH2のwindow sizeと
41    // 合わせておく必要がある。(2004.10.17 yutaka)
42  void PKT_init(PTInstVar pvar)  //#define READAMOUNT 65536
43  {  // 65536 -> 131072 へ拡張。(2007.10.29 maya)
44          buf_create(&pvar->pkt_state.buf, &pvar->pkt_state.buflen);  #define READAMOUNT CHAN_SES_WINDOW_DEFAULT
45          pvar->pkt_state.datastart = 0;  
46          pvar->pkt_state.datalen = 0;  void PKT_init(PTInstVar pvar)
47          pvar->pkt_state.seen_server_ID = FALSE;  {
48          pvar->pkt_state.seen_newline = FALSE;          buf_create(&pvar->pkt_state.buf, &pvar->pkt_state.buflen);
49          pvar->pkt_state.predecrypted_packet = FALSE;          pvar->pkt_state.datastart = 0;
50  }          pvar->pkt_state.datalen = 0;
51            pvar->pkt_state.seen_server_ID = FALSE;
52  /* Read some data, leave no more than up_to_amount bytes in the buffer,          pvar->pkt_state.seen_newline = FALSE;
53     return the number of bytes read or -1 on error or blocking. */          pvar->pkt_state.predecrypted_packet = FALSE;
54  static int recv_data(PTInstVar pvar, unsigned long up_to_amount)  }
55  {  
56          int amount_read;  /* Read some data, leave no more than up_to_amount bytes in the buffer,
57       return the number of bytes read or -1 on error or blocking. */
58          /* Shuffle data to the start of the buffer */  static int recv_data(PTInstVar pvar, unsigned long up_to_amount)
59          if (pvar->pkt_state.datastart != 0) {  {
60                  memmove(pvar->pkt_state.buf,          int amount_read;
61                                  pvar->pkt_state.buf + pvar->pkt_state.datastart,  
62                                  pvar->pkt_state.datalen);          /* Shuffle data to the start of the buffer */
63                  pvar->pkt_state.datastart = 0;          if (pvar->pkt_state.datastart != 0) {
64          }                  memmove(pvar->pkt_state.buf,
65                            pvar->pkt_state.buf + pvar->pkt_state.datastart,
66          buf_ensure_size(&pvar->pkt_state.buf, &pvar->pkt_state.buflen,                          pvar->pkt_state.datalen);
67                                          up_to_amount);                  pvar->pkt_state.datastart = 0;
68            }
69          _ASSERT(pvar->pkt_state.buf != NULL);  
70            buf_ensure_size(&pvar->pkt_state.buf, &pvar->pkt_state.buflen,
71          amount_read = (pvar->Precv) (pvar->socket,                          up_to_amount);
72                                                                   pvar->pkt_state.buf +  
73                                                                   pvar->pkt_state.datalen,          _ASSERT(pvar->pkt_state.buf != NULL);
74                                                                   up_to_amount - pvar->pkt_state.datalen,  
75                                                                   0);          amount_read = (pvar->Precv) (pvar->socket,
76                                         pvar->pkt_state.buf +
77          if (amount_read > 0) {                                       pvar->pkt_state.datalen,
78                  /* Update seen_newline if necessary */                                       up_to_amount - pvar->pkt_state.datalen,
79                  if (!pvar->pkt_state.seen_server_ID                                       0);
80                          && !pvar->pkt_state.seen_newline) {  
81                          int i;          if (amount_read > 0) {
82                    /* Update seen_newline if necessary */
83                          for (i = 0; i < amount_read; i++) {                  if (!pvar->pkt_state.seen_server_ID
84                                  if (pvar->pkt_state.buf[pvar->pkt_state.datalen + i] ==                   && !pvar->pkt_state.seen_newline) {
85                                          '\n') {                          int i;
86                                          pvar->pkt_state.seen_newline = 1;  
87                                  }                          for (i = 0; i < amount_read; i++) {
88                          }                                  if (pvar->pkt_state.buf[pvar->pkt_state.datalen + i] ==
89                  }                                      '\n') {
90                                            pvar->pkt_state.seen_newline = 1;
91                  pvar->pkt_state.datalen += amount_read;                                  }
92          }                          }
93                    }
94          return amount_read;  
95  }                  pvar->pkt_state.datalen += amount_read;
96            }
97    
98  // 改行コードが出てくるまで読む          return amount_read;
99  static int recv_line_data(PTInstVar pvar)  }
100  {  
101          int amount_read;  
102          char buf[256];  // 改行コードが出てくるまで読む
103          size_t up_to_amount = sizeof(buf);  static int recv_line_data(PTInstVar pvar)
104          int i;  {
105            int amount_read;
106          /* Shuffle data to the start of the buffer */          char buf[256];
107          if (pvar->pkt_state.datastart != 0) {          size_t up_to_amount = sizeof(buf);
108                  memmove(pvar->pkt_state.buf,          int i;
109                                  pvar->pkt_state.buf + pvar->pkt_state.datastart,  
110                                  pvar->pkt_state.datalen);          /* Shuffle data to the start of the buffer */
111                  pvar->pkt_state.datastart = 0;          if (pvar->pkt_state.datastart != 0) {
112          }                  memmove(pvar->pkt_state.buf,
113                            pvar->pkt_state.buf + pvar->pkt_state.datastart,
114          buf_ensure_size(&pvar->pkt_state.buf, &pvar->pkt_state.buflen,                          pvar->pkt_state.datalen);
115                                          up_to_amount);                  pvar->pkt_state.datastart = 0;
116            }
117          for (i = 0 ; i < (int)up_to_amount ; i++) {  
118                  amount_read = (pvar->Precv) (pvar->socket,          buf_ensure_size(&pvar->pkt_state.buf, &pvar->pkt_state.buflen,
119                                                                          &buf[i],                          up_to_amount);
120                                                                          1,  
121                                                                          0);          for (i = 0 ; i < (int)up_to_amount ; i++) {
122                  if (amount_read != 1) {                  amount_read = (pvar->Precv) (pvar->socket,
123                          return 0; // error                                               &buf[i], 1, 0);
124                  }                  if (amount_read != 1) {
125                            return 0; // error
126                  pvar->pkt_state.datalen += amount_read;                  }
127    
128                  if (buf[i] == '\n') { // 0x0a                  pvar->pkt_state.datalen += amount_read;
129                          buf[i+1] = 0;  
130                          break;                  if (buf[i] == '\n') { // 0x0a
131                  }                          buf[i+1] = 0;
132          }                          break;
133          amount_read = i + 1; // 読み込みサイズ（LFも含む）                  }
134          memcpy(pvar->pkt_state.buf, buf, amount_read);          }
135            amount_read = i + 1; // 読み込みサイズ（LFも含む）
136          pvar->pkt_state.seen_newline = 1;          memcpy(pvar->pkt_state.buf, buf, amount_read);
137    
138          return amount_read;          pvar->pkt_state.seen_newline = 1;
139  }  
140            return amount_read;
141    }
142  /* This function does two things:  
143     -- reads data from the sshd and feeds the SSH protocol packets to ssh.c  
144     -- copies any available decrypted session data into the application buffer  /* This function does two things:
145  */     -- reads data from the sshd and feeds the SSH protocol packets to ssh.c
146  int PKT_recv(PTInstVar pvar, char FAR * buf, int buflen)     -- copies any available decrypted session data into the application buffer
147  {  */
148          int amount_in_buf = 0;  int PKT_recv(PTInstVar pvar, char *buf, int buflen)
149          BOOL connection_closed = FALSE;  {
150            int amount_in_buf = 0;
151          while (SSH_is_any_payload(pvar) ? buflen > 0 : !connection_closed) {          BOOL connection_closed = FALSE;
152                  if (SSH_is_any_payload(pvar)) {  
153                          /* ssh.c has some session data for us to give to Teraterm. */          while (SSH_is_any_payload(pvar) ? buflen > 0 : !connection_closed) {
154                          int grabbed = SSH_extract_payload(pvar, buf, buflen);                  if (SSH_is_any_payload(pvar)) {
155                            /* ssh.c has some session data for us to give to Tera Term. */
156                          amount_in_buf += grabbed;                          int grabbed = SSH_extract_payload(pvar, buf, buflen);
157                          buf += grabbed;  
158                          buflen -= grabbed;                          amount_in_buf += grabbed;
159                            buf += grabbed;
160                  } else if (!pvar->pkt_state.seen_server_ID &&                          buflen -= grabbed;
161                                     (pvar->pkt_state.seen_newline  
162                                          || pvar->pkt_state.datalen >= 255)) {                  } else if (!pvar->pkt_state.seen_server_ID &&
163                          /* We're looking for the initial ID string and either we've seen the                             (pvar->pkt_state.seen_newline
164                             terminating newline, or we've exceeded the limit at which we should see                              || pvar->pkt_state.datalen >= 255)) {
165                             a newline. */                          /* We're looking for the initial ID string and either we've seen the
166                          unsigned int i;                             terminating newline, or we've exceeded the limit at which we should see
167                               a newline. */
168                          for (i = 0;                          unsigned int i;
169                                   pvar->pkt_state.buf[i] != '\n'  
170                                   && i < pvar->pkt_state.datalen; i++) {                          for (i = 0;
171                          }                               pvar->pkt_state.buf[i] != '\n'
172                          if (pvar->pkt_state.buf[i] == '\n') {                               && i < pvar->pkt_state.datalen; i++) {
173                                  i++;                          }
174                          }                          if (pvar->pkt_state.buf[i] == '\n') {
175                                    i++;
176                          // SSHサーバのバージョンチェックを行う                          }
177                          if (SSH_handle_server_ID(pvar, pvar->pkt_state.buf, i)) {  
178                                  pvar->pkt_state.seen_server_ID = 1;                          // SSHサーバのバージョンチェックを行う
179                            if (SSH_handle_server_ID(pvar, pvar->pkt_state.buf, i)) {
180                                  if (SSHv1(pvar)) {                                  pvar->pkt_state.seen_server_ID = 1;
181    
182                                  } else { // for SSH2(yutaka)                                  if (SSHv1(pvar)) {
183                                          // send Key Exchange Init  
184                                          SSH2_send_kexinit(pvar);                                  } else { // for SSH2(yutaka)
185                                  }                                          // send Key Exchange Init
186                                            SSH2_send_kexinit(pvar);
187                          }                                  }
188    
189                          pvar->pkt_state.datastart += i;                          } else {
190                          pvar->pkt_state.datalen -= i;                                  // reset flag to re-read server ID (2008.1.24 yutaka)
191                                    pvar->pkt_state.seen_newline = 0;
192                  } else if (pvar->pkt_state.seen_server_ID  
193                                     && pvar->pkt_state.datalen >=                          }
194                                     (unsigned int) SSH_get_min_packet_size(pvar)) {  
195                          char FAR *data =                          pvar->pkt_state.datastart += i;
196                                  pvar->pkt_state.buf + pvar->pkt_state.datastart;                          pvar->pkt_state.datalen -= i;
197                          uint32 padding;  
198                          uint32 pktsize;                  } else if (pvar->pkt_state.seen_server_ID
199                          uint32 total_packet_size;                             && pvar->pkt_state.datalen >=
200                               (unsigned int) SSH_get_min_packet_size(pvar)) {
201                          //debug_print(10, data, pvar->pkt_state.datalen);                          char *data =
202                                    pvar->pkt_state.buf + pvar->pkt_state.datastart;
203                          // SSH2なら暗号化パケットの一部を復号化する。                          uint32 padding;
204                          if (!pvar->pkt_state.predecrypted_packet) {                          uint32 pktsize;
205                                  SSH_predecrpyt_packet(pvar, data);                          uint32 total_packet_size;
206    
207                                  if (SSHv1(pvar)) {                          //debug_print(10, data, pvar->pkt_state.datalen);
208                                          pvar->pkt_state.predecrypted_packet = TRUE;  
209                                  } else { // for SSH2(yutaka)                          // 暗号化パケットの一部を復号化する。
210                                          // do nothing                          if (!pvar->pkt_state.predecrypted_packet) {
211                                          pvar->pkt_state.predecrypted_packet = TRUE;                                  SSH_predecrpyt_packet(pvar, data);
212                                  }                                  pvar->pkt_state.predecrypted_packet = TRUE;
213                          }                          }
214    
215                          if (SSHv1(pvar)) {                          if (SSHv1(pvar)) {
216                                  uint32 realpktsize = get_uint32_MSBfirst(data);                                  uint32 realpktsize = get_uint32_MSBfirst(data);
217    
218                                  padding = 8 - (realpktsize % 8);                                  padding = 8 - (realpktsize % 8);
219                                  pktsize = realpktsize + padding;                                  pktsize = realpktsize + padding;
220                          } else {                          } else {
221                                  // SSH2のパケットは先頭に packet-size(4)+padding(1)+type(1) が続く。                                  // SSH2のパケットは先頭に packet-size(4)+padding(1)+type(1) が続く。
222                                  pktsize = get_uint32_MSBfirst(data);                                  pktsize = get_uint32_MSBfirst(data);
223                                  padding = (unsigned char) data[4];                                  padding = (unsigned char) data[4];
224                          }                          }
225    
226                          // パケット(TCPペイロード)の全体のサイズは、SSHペイロード＋4（＋MAC）となる。                          // パケット(TCPペイロード)の全体のサイズは、SSHペイロード＋4（＋MAC）となる。
227                          // +4は、SSHペイロードのサイズを格納している部分（int型）。                          // +4は、SSHペイロードのサイズを格納している部分（int型）。
228                          total_packet_size = pktsize + 4 + SSH_get_clear_MAC_size(pvar);                          total_packet_size = pktsize + 4 + SSH_get_clear_MAC_size(pvar);
229    
230                          if (total_packet_size <= pvar->pkt_state.datalen) {                          if (total_packet_size <= pvar->pkt_state.datalen) {
231                                  /* the data must be 4 byte aligned. */                                  /* the data must be 4 byte aligned. */
232                                  SSH_handle_packet(pvar, data, pktsize, padding);                                  SSH_handle_packet(pvar, data, pktsize, padding);
233                                  pvar->pkt_state.predecrypted_packet = FALSE;                                  pvar->pkt_state.predecrypted_packet = FALSE;
234    
235                                  pvar->pkt_state.datastart += total_packet_size;                                  pvar->pkt_state.datastart += total_packet_size;
236                                  pvar->pkt_state.datalen -= total_packet_size;                                  pvar->pkt_state.datalen -= total_packet_size;
237    
238                          } else if (total_packet_size > 4 * 1024 * 1024) {                          } else if (total_packet_size > PACKET_MAX_SIZE) {
239                                  // 4MBを超える巨大なパケットが届いたら、異常終了する。                                  // 4MBを超える巨大なパケットが届いたら、異常終了する。
240                                  // 実際にはデータ化けで復号失敗時に、誤認識することが多い。                                  // 実際にはデータ化けで復号失敗時に、誤認識することが多い。
241                                  notify_fatal_error(pvar,                                  UTIL_get_lang_msg("MSG_PKT_OVERSIZED_ERROR", pvar,
242                                                                     "Oversized packet received from server; connection will close.");                                                    "Oversized packet received from server; connection will close.");
243                          } else {                                  notify_fatal_error(pvar, pvar->ts->UIMsg, TRUE);
244                                  int amount_read =                          } else {
245                                          recv_data(pvar, max(total_packet_size, READAMOUNT));                                  int amount_read =
246                                            recv_data(pvar, max(total_packet_size, READAMOUNT));
247                                  if (amount_read == SOCKET_ERROR) {  
248                                          if (amount_in_buf == 0) {                                  if (amount_read == SOCKET_ERROR) {
249                                                  return SOCKET_ERROR;                                          if (amount_in_buf == 0) {
250                                          } else {                                                  return SOCKET_ERROR;
251                                                  return amount_in_buf;                                          } else {
252                                          }                                                  return amount_in_buf;
253                                  } else {                                          }
254                                          if (amount_read == 0) {                                  } else {
255                                                  connection_closed = TRUE;                                          if (amount_read == 0) {
256                                          }                                                  connection_closed = TRUE;
257                                  }                                          }
258                          }                                  }
259                            }
260    
261                  } else {  
262                          // パケットの受信（最大60KB）                  } else {
263                          int amount_read;                          // パケットの受信（最大60KB）
264                            int amount_read;
265                          if (pvar->pkt_state.seen_server_ID == 0) {  
266                                  //amount_read = recv_line_data(pvar);                          if (pvar->pkt_state.seen_server_ID == 0) {
267                                  amount_read = recv_data(pvar, READAMOUNT);                                  //amount_read = recv_line_data(pvar);
268                                    amount_read = recv_data(pvar, READAMOUNT);
269                          } else {  
270                                  amount_read = recv_data(pvar, READAMOUNT);                          } else {
271                                    amount_read = recv_data(pvar, READAMOUNT);
272                          }  
273                            }
274                          if (amount_read == SOCKET_ERROR) {  
275                                  if (amount_in_buf == 0) {                          if (amount_read == SOCKET_ERROR) {
276                                          return SOCKET_ERROR;                                  if (amount_in_buf == 0) {
277                                  } else {                                          return SOCKET_ERROR;
278                                          return amount_in_buf;                                  } else {
279                                  }                                          return amount_in_buf;
280                          } else if (amount_read == 0) {                                  }
281                                  connection_closed = TRUE;                          } else if (amount_read == 0) {
282                          }                                  connection_closed = TRUE;
283                  }                          }
284                    }
285                  if (pvar->fatal_error) {  
286                          return amount_in_buf;                  if (pvar->fatal_error) {
287                  }                          return amount_in_buf;
288          }                  }
289            }
290          if (SSH_is_any_payload(pvar)) {  
291                  PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,          if (SSH_is_any_payload(pvar)) {
292                                          pvar->socket, MAKELPARAM(FD_READ, 0));                  PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
293          }                              pvar->socket, MAKELPARAM(FD_READ, 0));
294            }
295          return amount_in_buf;  
296  }          return amount_in_buf;
297    }
298  void PKT_end(PTInstVar pvar)  
299  {  void PKT_end(PTInstVar pvar)
300          buf_destroy(&pvar->pkt_state.buf, &pvar->pkt_state.buflen);  {
301  }          buf_destroy(&pvar->pkt_state.buf, &pvar->pkt_state.buflen);
302    }
Legend:
Removed from v.2729  
changed lines
  Added in v.6841
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help