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 3134 by doda, Fri Jun 20 11:58:47 2008 UTC trunk/ttssh2/ttxssh/pkt.c revision 6969 by doda, Thu Nov 2 11:37:41 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 CHAN_SES_WINDOW_DEFAULT
40  //#define READAMOUNT 65536  
41  // 65536 -> 131072 へ拡張。(2007.10.29 maya)  void PKT_init(PTInstVar pvar)
42  #define READAMOUNT CHAN_SES_WINDOW_DEFAULT  {
43            buf_create(&pvar->pkt_state.buf, &pvar->pkt_state.buflen);
44  void PKT_init(PTInstVar pvar)          pvar->pkt_state.datastart = 0;
45  {          pvar->pkt_state.datalen = 0;
46          buf_create(&pvar->pkt_state.buf, &pvar->pkt_state.buflen);          pvar->pkt_state.seen_server_ID = FALSE;
47          pvar->pkt_state.datastart = 0;          pvar->pkt_state.seen_newline = FALSE;
48          pvar->pkt_state.datalen = 0;          pvar->pkt_state.predecrypted_packet = FALSE;
49          pvar->pkt_state.seen_server_ID = FALSE;  }
50          pvar->pkt_state.seen_newline = FALSE;  
51          pvar->pkt_state.predecrypted_packet = FALSE;  /* Read some data, leave no more than up_to_amount bytes in the buffer,
52  }     return the number of bytes read or -1 on error or blocking. */
53    static int recv_data(PTInstVar pvar, unsigned long up_to_amount)
54  /* Read some data, leave no more than up_to_amount bytes in the buffer,  {
55     return the number of bytes read or -1 on error or blocking. */          int amount_read;
56  static int recv_data(PTInstVar pvar, unsigned long up_to_amount)  
57  {          /* Shuffle data to the start of the buffer */
58          int amount_read;          if (pvar->pkt_state.datastart != 0) {
59                    memmove(pvar->pkt_state.buf,
60          /* Shuffle data to the start of the buffer */                          pvar->pkt_state.buf + pvar->pkt_state.datastart,
61          if (pvar->pkt_state.datastart != 0) {                          pvar->pkt_state.datalen);
62                  memmove(pvar->pkt_state.buf,                  pvar->pkt_state.datastart = 0;
63                          pvar->pkt_state.buf + pvar->pkt_state.datastart,          }
64                          pvar->pkt_state.datalen);  
65                  pvar->pkt_state.datastart = 0;          buf_ensure_size(&pvar->pkt_state.buf, &pvar->pkt_state.buflen, up_to_amount);
66          }  
67            _ASSERT(pvar->pkt_state.buf != NULL);
68          buf_ensure_size(&pvar->pkt_state.buf, &pvar->pkt_state.buflen,  
69                          up_to_amount);          amount_read = (pvar->Precv) (pvar->socket,
70                                         pvar->pkt_state.buf + pvar->pkt_state.datalen,
71          _ASSERT(pvar->pkt_state.buf != NULL);                                       up_to_amount - pvar->pkt_state.datalen,
72                                         0);
73          amount_read = (pvar->Precv) (pvar->socket,  
74                                       pvar->pkt_state.buf +          if (amount_read > 0) {
75                                       pvar->pkt_state.datalen,                  /* Update seen_newline if necessary */
76                                       up_to_amount - pvar->pkt_state.datalen,                  if (!pvar->pkt_state.seen_server_ID && !pvar->pkt_state.seen_newline) {
77                                       0);                          int i;
78    
79          if (amount_read > 0) {                          for (i = 0; i < amount_read; i++) {
80                  /* Update seen_newline if necessary */                                  if (pvar->pkt_state.buf[pvar->pkt_state.datalen + i] == '\n') {
81                  if (!pvar->pkt_state.seen_server_ID                                          pvar->pkt_state.seen_newline = 1;
82                   && !pvar->pkt_state.seen_newline) {                                  }
83                          int i;                          }
84                    }
85                          for (i = 0; i < amount_read; i++) {                  pvar->pkt_state.datalen += amount_read;
86                                  if (pvar->pkt_state.buf[pvar->pkt_state.datalen + i] ==          }
87                                      '\n') {  
88                                          pvar->pkt_state.seen_newline = 1;          return amount_read;
89                                  }  }
90                          }  
91                  }  
92    // 改行コードが出てくるまで読む
93                  pvar->pkt_state.datalen += amount_read;  static int recv_line_data(PTInstVar pvar)
94          }  {
95            int amount_read;
96          return amount_read;          char buf[256];
97  }          size_t up_to_amount = sizeof(buf);
98            int i;
99    
100  // 改行コードが出てくるまで読む          /* Shuffle data to the start of the buffer */
101  static int recv_line_data(PTInstVar pvar)          if (pvar->pkt_state.datastart != 0) {
102  {                  memmove(pvar->pkt_state.buf,
103          int amount_read;                          pvar->pkt_state.buf + pvar->pkt_state.datastart,
104          char buf[256];                          pvar->pkt_state.datalen);
105          size_t up_to_amount = sizeof(buf);                  pvar->pkt_state.datastart = 0;
106          int i;          }
107    
108          /* Shuffle data to the start of the buffer */          buf_ensure_size(&pvar->pkt_state.buf, &pvar->pkt_state.buflen, up_to_amount);
109          if (pvar->pkt_state.datastart != 0) {  
110                  memmove(pvar->pkt_state.buf,          for (i = 0 ; i < (int)up_to_amount ; i++) {
111                          pvar->pkt_state.buf + pvar->pkt_state.datastart,                  amount_read = (pvar->Precv) (pvar->socket, &buf[i], 1, 0);
112                          pvar->pkt_state.datalen);                  if (amount_read != 1) {
113                  pvar->pkt_state.datastart = 0;                          return 0; // error
114          }                  }
115    
116          buf_ensure_size(&pvar->pkt_state.buf, &pvar->pkt_state.buflen,                  pvar->pkt_state.datalen += amount_read;
117                          up_to_amount);  
118                    if (buf[i] == '\n') { // 0x0a
119          for (i = 0 ; i < (int)up_to_amount ; i++) {                          buf[i+1] = 0;
120                  amount_read = (pvar->Precv) (pvar->socket,                          break;
121                                               &buf[i], 1, 0);                  }
122                  if (amount_read != 1) {          }
123                          return 0; // error          amount_read = i + 1; // 読み込みサイズ（LFも含む）
124                  }          memcpy(pvar->pkt_state.buf, buf, amount_read);
125    
126                  pvar->pkt_state.datalen += amount_read;          pvar->pkt_state.seen_newline = 1;
127    
128                  if (buf[i] == '\n') { // 0x0a          return amount_read;
129                          buf[i+1] = 0;  }
130                          break;  
131                  }  
132          }  /* This function does two things:
133          amount_read = i + 1; // 読み込みサイズ（LFも含む）     -- reads data from the sshd and feeds the SSH protocol packets to ssh.c
134          memcpy(pvar->pkt_state.buf, buf, amount_read);     -- copies any available decrypted session data into the application buffer
135    */
136          pvar->pkt_state.seen_newline = 1;  int PKT_recv(PTInstVar pvar, char *buf, int buflen)
137    {
138          return amount_read;          int amount_in_buf = 0;
139  }          BOOL connection_closed = FALSE;
140    
141            while (SSH_is_any_payload(pvar) ? buflen > 0 : !connection_closed) {
142  /* This function does two things:                  if (SSH_is_any_payload(pvar)) {
143     -- reads data from the sshd and feeds the SSH protocol packets to ssh.c                          /* ssh.c has some session data for us to give to Tera Term. */
144     -- copies any available decrypted session data into the application buffer                          int grabbed = SSH_extract_payload(pvar, buf, buflen);
145  */  
146  int PKT_recv(PTInstVar pvar, char FAR * buf, int buflen)                          amount_in_buf += grabbed;
147  {                          buf += grabbed;
148          int amount_in_buf = 0;                          buflen -= grabbed;
149          BOOL connection_closed = FALSE;                  }
150                    else if (!pvar->pkt_state.seen_server_ID && (pvar->pkt_state.seen_newline || pvar->pkt_state.datalen >= 255)) {
151          while (SSH_is_any_payload(pvar) ? buflen > 0 : !connection_closed) {                          /*
152                  if (SSH_is_any_payload(pvar)) {                           * We're looking for the initial ID string and either we've seen the
153                          /* ssh.c has some session data for us to give to Tera Term. */                           * terminating newline, or we've exceeded the limit at which we should see a newline.
154                          int grabbed = SSH_extract_payload(pvar, buf, buflen);                           */
155                            unsigned int i;
156                          amount_in_buf += grabbed;  
157                          buf += grabbed;                          for (i = 0; pvar->pkt_state.buf[i] != '\n' && i < pvar->pkt_state.datalen; i++) {
158                          buflen -= grabbed;                          }
159                            if (pvar->pkt_state.buf[i] == '\n') {
160                  } else if (!pvar->pkt_state.seen_server_ID &&                                  i++;
161                             (pvar->pkt_state.seen_newline                          }
162                              || pvar->pkt_state.datalen >= 255)) {  
163                          /* We're looking for the initial ID string and either we've seen the                          // SSHサーバのバージョンチェックを行う
164                             terminating newline, or we've exceeded the limit at which we should see                          if (SSH_handle_server_ID(pvar, pvar->pkt_state.buf, i)) {
165                             a newline. */                                  pvar->pkt_state.seen_server_ID = 1;
166                          unsigned int i;  
167                                    if (SSHv2(pvar)) {
168                          for (i = 0;                                          // send Key Exchange Init
169                               pvar->pkt_state.buf[i] != '\n'                                          SSH2_send_kexinit(pvar);
170                               && i < pvar->pkt_state.datalen; i++) {                                  }
171                          }                          } else {
172                          if (pvar->pkt_state.buf[i] == '\n') {                                  // reset flag to re-read server ID (2008.1.24 yutaka)
173                                  i++;                                  pvar->pkt_state.seen_newline = 0;
174                          }                          }
175    
176                          // SSHサーバのバージョンチェックを行う                          pvar->pkt_state.datastart += i;
177                          if (SSH_handle_server_ID(pvar, pvar->pkt_state.buf, i)) {                          pvar->pkt_state.datalen -= i;
178                                  pvar->pkt_state.seen_server_ID = 1;                  }
179                    else if (pvar->pkt_state.seen_server_ID && pvar->pkt_state.datalen >= (unsigned int) SSH_get_min_packet_size(pvar)) {
180                                  if (SSHv1(pvar)) {                          char *data = pvar->pkt_state.buf + pvar->pkt_state.datastart;
181                            uint32 padding;
182                                  } else { // for SSH2(yutaka)                          uint32 pktsize;
183                                          // send Key Exchange Init                          uint32 total_packet_size;
184                                          SSH2_send_kexinit(pvar);                          struct Mac *mac = &pvar->ssh2_keys[MODE_IN].mac;
185                                  }                          int etm;
186    
187                          } else {                          etm = mac && mac->enabled && mac->etm;
188                                  // reset flag to re-read server ID (2008.1.24 yutaka)  
189                                  pvar->pkt_state.seen_newline = 0;                          // 暗号化パケットの一部を復号化する。
190                            if (!pvar->pkt_state.predecrypted_packet && !etm) {
191                          }                                  SSH_predecrpyt_packet(pvar, data);
192                                    pvar->pkt_state.predecrypted_packet = TRUE;
193                          pvar->pkt_state.datastart += i;                          }
194                          pvar->pkt_state.datalen -= i;  
195                            if (SSHv1(pvar)) {
196                  } else if (pvar->pkt_state.seen_server_ID                                  uint32 realpktsize = get_uint32_MSBfirst(data);
197                             && pvar->pkt_state.datalen >=  
198                             (unsigned int) SSH_get_min_packet_size(pvar)) {                                  padding = 8 - (realpktsize % 8);
199                          char FAR *data =                                  pktsize = realpktsize + padding;
200                                  pvar->pkt_state.buf + pvar->pkt_state.datastart;                          } else {
201                          uint32 padding;                                  // SSH2のパケットは先頭に packet-size(4)+padding(1)+type(1) が続く。
202                          uint32 pktsize;                                  pktsize = get_uint32_MSBfirst(data);
203                          uint32 total_packet_size;                                  if (etm) {
204                                            padding = 0;
205                          //debug_print(10, data, pvar->pkt_state.datalen);                                  }
206                                    else {
207                          // SSH2なら暗号化パケットの一部を復号化する。                                          padding = (unsigned char) data[4];
208                          if (!pvar->pkt_state.predecrypted_packet) {                                  }
209                                  //DEBUG_PRINT_TO_FILE(0, data, pvar->pkt_state.datalen);                          }
210                                  SSH_predecrpyt_packet(pvar, data);  
211                            // パケット(TCPペイロード)の全体のサイズは、SSHペイロード＋4（＋MAC）となる。
212                                  if (SSHv1(pvar)) {                          // +4は、SSHペイロードのサイズを格納している部分（int型）。
213                                          pvar->pkt_state.predecrypted_packet = TRUE;                          total_packet_size = pktsize + 4 + SSH_get_clear_MAC_size(pvar);
214                                  } else { // for SSH2(yutaka)  
215                                          // do nothing                          if (total_packet_size <= pvar->pkt_state.datalen) {
216                                          pvar->pkt_state.predecrypted_packet = TRUE;                                  /* the data must be 4 byte aligned. */
217                                  }                                  if (SSHv1(pvar)) {
218                          }                                          SSH_handle_packet1(pvar, data, pktsize, padding);
219                                    }
220                          if (SSHv1(pvar)) {                                  else {
221                                  uint32 realpktsize = get_uint32_MSBfirst(data);                                          SSH_handle_packet2(pvar, data, pktsize, padding, etm);
222                                    }
223                                  padding = 8 - (realpktsize % 8);                                  pvar->pkt_state.predecrypted_packet = FALSE;
224                                  pktsize = realpktsize + padding;  
225                          } else {                                  pvar->pkt_state.datastart += total_packet_size;
226                                  // SSH2のパケットは先頭に packet-size(4)+padding(1)+type(1) が続く。                                  pvar->pkt_state.datalen -= total_packet_size;
227                                  pktsize = get_uint32_MSBfirst(data);  
228                                  padding = (unsigned char) data[4];                          } else if (total_packet_size > PACKET_MAX_SIZE) {
229                          }                                  // 4MBを超える巨大なパケットが届いたら、異常終了する。
230                                    // 実際にはデータ化けで復号失敗時に、誤認識することが多い。
231                          // パケット(TCPペイロード)の全体のサイズは、SSHペイロード＋4（＋MAC）となる。                                  UTIL_get_lang_msg("MSG_PKT_OVERSIZED_ERROR", pvar,
232                          // +4は、SSHペイロードのサイズを格納している部分（int型）。                                                    "Oversized packet received from server; connection will close.");
233                          total_packet_size = pktsize + 4 + SSH_get_clear_MAC_size(pvar);                                  notify_fatal_error(pvar, pvar->ts->UIMsg, TRUE);
234                            } else {
235                          if (total_packet_size <= pvar->pkt_state.datalen) {                                  int amount_read = recv_data(pvar, max(total_packet_size, READAMOUNT));
236                                  /* the data must be 4 byte aligned. */  
237                                  SSH_handle_packet(pvar, data, pktsize, padding);                                  if (amount_read == SOCKET_ERROR) {
238                                  pvar->pkt_state.predecrypted_packet = FALSE;                                          if (amount_in_buf == 0) {
239                                                    return SOCKET_ERROR;
240                                  pvar->pkt_state.datastart += total_packet_size;                                          } else {
241                                  pvar->pkt_state.datalen -= total_packet_size;                                                  return amount_in_buf;
242                                            }
243                          } else if (total_packet_size > 4 * 1024 * 1024) {                                  } else {
244                                  // 4MBを超える巨大なパケットが届いたら、異常終了する。                                          if (amount_read == 0) {
245                                  // 実際にはデータ化けで復号失敗時に、誤認識することが多い。                                                  connection_closed = TRUE;
246                                  UTIL_get_lang_msg("MSG_PKT_OVERSIZED_ERROR", pvar,                                          }
247                                                                    "Oversized packet received from server; connection will close.");                                  }
248                                  notify_fatal_error(pvar, pvar->ts->UIMsg);                          }
249                          } else {                  } else {
250                                  int amount_read =                          // パケットの受信
251                                          recv_data(pvar, max(total_packet_size, READAMOUNT));                          int amount_read;
252    
253                                  if (amount_read == SOCKET_ERROR) {                          amount_read = recv_data(pvar, READAMOUNT);
254                                          if (amount_in_buf == 0) {  
255                                                  return SOCKET_ERROR;                          if (amount_read == SOCKET_ERROR) {
256                                          } else {                                  if (amount_in_buf == 0) {
257                                                  return amount_in_buf;                                          return SOCKET_ERROR;
258                                          }                                  } else {
259                                  } else {                                          return amount_in_buf;
260                                          if (amount_read == 0) {                                  }
261                                                  connection_closed = TRUE;                          } else if (amount_read == 0) {
262                                          }                                  connection_closed = TRUE;
263                                  }                          }
264                          }                  }
265    
266                    if (pvar->fatal_error) {
267                  } else {                          return amount_in_buf;
268                          // パケットの受信（最大60KB）                  }
269                          int amount_read;          }
270    
271                          if (pvar->pkt_state.seen_server_ID == 0) {          if (SSH_is_any_payload(pvar)) {
272                                  //amount_read = recv_line_data(pvar);                  PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY, pvar->socket, MAKELPARAM(FD_READ, 0));
273                                  amount_read = recv_data(pvar, READAMOUNT);          }
274    
275                          } else {          return amount_in_buf;
276                                  amount_read = recv_data(pvar, READAMOUNT);  }
277    
278                          }  void PKT_end(PTInstVar pvar)
279    {
280                          if (amount_read == SOCKET_ERROR) {          buf_destroy(&pvar->pkt_state.buf, &pvar->pkt_state.buflen);
281                                  if (amount_in_buf == 0) {  }
                                         return SOCKET_ERROR;  
                                 } else {  
                                         return amount_in_buf;  
                                 }  
                         } else if (amount_read == 0) {  
                                 connection_closed = TRUE;  
                         }  
                 }  
   
                 if (pvar->fatal_error) {  
                         return amount_in_buf;  
                 }  
         }  
   
         if (SSH_is_any_payload(pvar)) {  
                 PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,  
                             pvar->socket, MAKELPARAM(FD_READ, 0));  
         }  
   
         return amount_in_buf;  
 }  
   
 void PKT_end(PTInstVar pvar)  
 {  
         buf_destroy(&pvar->pkt_state.buf, &pvar->pkt_state.buflen);  
 }  
Legend:
Removed from v.3134  
changed lines
  Added in v.6969
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help