Use C SSH buffer for socket_buffer, restruct parseData

7 files changed, 31 insertions, 32 deletions

diff --git a/src/protocol/fqterm_ssh_socket.cpp b/src/protocol/fqterm_ssh_socket.cpp
index ea0f774..2755609 100644
--- a/src/protocol/fqterm_ssh_socket.cpp
+++ b/src/protocol/fqterm_ssh_socket.cpp
@@ -48,7 +48,7 @@ FQTermSSHSocket::FQTermSSHSocket(int col, int row, const QString& termtype, cons
 
   input_buffer_ = NULL;
   output_buffer_ = NULL;
-  socket_buffer_ = NULL;
+  buffer_init(&socket_buffer);
   packet_receiver_ = NULL;
   packet_sender_ = NULL;
   key_exchanger_ = NULL;
@@ -72,7 +72,7 @@ FQTermSSHSocket::~FQTermSSHSocket() {
   delete private_socket_;
   delete input_buffer_;
   delete output_buffer_;
-  delete socket_buffer_;
+  buffer_deinit(&socket_buffer);
   delete packet_receiver_;
   delete packet_sender_;
   delete key_exchanger_;
@@ -87,7 +87,7 @@ void FQTermSSHSocket::init(int ssh_version) {
 
   delete input_buffer_;
   delete output_buffer_;
-  delete socket_buffer_;
+  buffer_clear(&socket_buffer);
   delete packet_receiver_;
   delete packet_sender_;
   delete key_exchanger_;
@@ -100,7 +100,6 @@ void FQTermSSHSocket::init(int ssh_version) {
   if (ssh_version == 1) {
     input_buffer_ = new FQTermSSHBuffer(1024);
     output_buffer_ = new FQTermSSHBuffer(1024);
-    socket_buffer_ = new FQTermSSHBuffer(1024);
     packet_receiver_ = new FQTermSSH1PacketReceiver;
     packet_sender_ = new FQTermSSH1PacketSender;
     key_exchanger_ = new FQTermSSH1Kex(SSH_V1_C, server_name_.toLatin1().constData());
@@ -130,7 +129,6 @@ void FQTermSSHSocket::init(int ssh_version) {
   } else {
     input_buffer_ = new FQTermSSHBuffer(1024);
     output_buffer_ = new FQTermSSHBuffer(1024);
-    socket_buffer_ = new FQTermSSHBuffer(1024);
     packet_receiver_ = new FQTermSSH2PacketReceiver;
     packet_sender_ = new FQTermSSH2PacketSender;
     key_exchanger_ = new FQTermSSH2Kex(SSH_V2_C, server_name_.toLatin1().constData());
@@ -249,8 +247,8 @@ void FQTermSSHSocket::parsePacket() {
   size = private_socket_->bytesAvailable();
   data = private_socket_->readBlock(size);
 
-  socket_buffer_->putRawData(data.data(), size);
-  packet_receiver_->parseData(socket_buffer_);
+  buffer_append(&socket_buffer, (const uint8_t*)data.data(), size);
+  packet_receiver_->parseData(&socket_buffer);
 }
 
 int FQTermSSHSocket::chooseVersion(const QString &ver) {
diff --git a/src/protocol/fqterm_ssh_socket.h b/src/protocol/fqterm_ssh_socket.h
index aa6fef4..e8b6dec 100644
--- a/src/protocol/fqterm_ssh_socket.h
+++ b/src/protocol/fqterm_ssh_socket.h
@@ -22,6 +22,7 @@
 #define FQTERM_SSH_SOCKET_H
 
 #include "fqterm_socket.h"
+#include "internal/buffer.h"
 
 
 namespace FQTerm {
@@ -58,7 +59,7 @@ private:
 
   FQTermSSHBuffer *output_buffer_;
 
-  FQTermSSHBuffer *socket_buffer_;
+	buffer socket_buffer; /* data received from the socket */
 
 
   FQTermSSHPacketReceiver *packet_receiver_;
diff --git a/src/protocol/internal/fqterm_ssh1_packet.cpp b/src/protocol/internal/fqterm_ssh1_packet.cpp
index 78a8bda..4398e3f 100644
--- a/src/protocol/internal/fqterm_ssh1_packet.cpp
+++ b/src/protocol/internal/fqterm_ssh1_packet.cpp
@@ -83,19 +83,19 @@ void FQTermSSH1PacketSender::makePacket()
 		cipher = new_3des_ssh1(0);
 	}
 
-void FQTermSSH1PacketReceiver::parseData(FQTermSSHBuffer *input) {
+void FQTermSSH1PacketReceiver::parseData(buffer *input) {
   u_int mycrc, gotcrc;
   u_char *buf = NULL;
   u_char *targetData = NULL;
   u_char *sourceData = NULL;
 
   // Get the length of the packet.
-  while (input->len() > 0) {
-    if (input->len() < 4) {
+  while (buffer_len(input) > 0) {
+    if (buffer_len(input) < 4) {
       FQ_TRACE("ssh1packet", 3) << "The packet is too small.";
       return ;
     }
-    buf = input->data();
+    buf = buffer_data(input);
     real_data_len_ = ntohu32(buf);
 
     if (real_data_len_ > SSH_BUFFER_MAX) {
@@ -110,18 +110,18 @@ void FQTermSSH1PacketReceiver::parseData(FQTermSSHBuffer *input) {
     buffer_clear(&recvbuf);
 
     // Get the data of the packet.
-    if (input->len() - 4 < (long)total_len) {
+    if (buffer_len(input) - 4 < (long)total_len) {
       FQ_TRACE("ssh1packet", 3) << "The packet is too small";
       return ;
     }
 
-    real_data_len_ = input->getInt() - 5;
+    real_data_len_ = buffer_get_u32(input) - 5;
     targetData = new u_char[total_len];
     sourceData = new u_char[total_len];
     memset(targetData, 0, total_len);
     memset(sourceData, 0, total_len);
 
-    input->getRawData((char*)sourceData, total_len);
+    buffer_get(input, sourceData, total_len);
     if (is_decrypt_) {
 	    cipher->crypt(cipher, sourceData, targetData, total_len);
     } else {
diff --git a/src/protocol/internal/fqterm_ssh1_packet.h b/src/protocol/internal/fqterm_ssh1_packet.h
index 8ea66c7..16af5c9 100644
--- a/src/protocol/internal/fqterm_ssh1_packet.h
+++ b/src/protocol/internal/fqterm_ssh1_packet.h
@@ -34,7 +34,7 @@ public:
 
 class FQTermSSH1PacketReceiver: public FQTermSSHPacketReceiver {
 public:
-  virtual void parseData(FQTermSSHBuffer *input);
+  virtual void parseData(buffer *input);
   FQTermSSH1PacketReceiver();
 };
 
diff --git a/src/protocol/internal/fqterm_ssh2_packet.cpp b/src/protocol/internal/fqterm_ssh2_packet.cpp
index 4399757..0069c84 100644
--- a/src/protocol/internal/fqterm_ssh2_packet.cpp
+++ b/src/protocol/internal/fqterm_ssh2_packet.cpp
@@ -125,15 +125,15 @@ void FQTermSSH2PacketSender::makePacket()
 //==============================================================================
 //FQTermSSH2PacketReceiver
 //==============================================================================
-void FQTermSSH2PacketReceiver::parseData(FQTermSSHBuffer *input) {
+void FQTermSSH2PacketReceiver::parseData(buffer *input) {
   FQ_TRACE("ssh2packet", 9) << "----------------------------Receive "
                             << (is_decrypt_ ? "Encrypted": "plain")
                             << " Packet----<<<<<<<";
-  while (input->len() > 0) {
+  while (buffer_len(input) > 0) {
     // 1. Check the ssh packet
-    if (input->len() < 16
-        || (is_decrypt_ && input->len() < cipher->blkSize)
-        || input->len() < last_expected_input_length_
+    if (buffer_len(input) < 16
+        || (is_decrypt_ && buffer_len(input) < cipher->blkSize)
+        || buffer_len(input) < last_expected_input_length_
         ) {
       FQ_TRACE("ssh2packet", 3)
           << "Got an incomplete packet. Wait for more data.";
@@ -143,7 +143,7 @@ void FQTermSSH2PacketReceiver::parseData(FQTermSSHBuffer *input) {
     if (last_expected_input_length_ == 0) {
       if (is_decrypt_) {
 			// decrypte the first block to get the packet_length field.
-			FQ_VERIFY(cipher->crypt(cipher, input->data(), input->data(), cipher->blkSize)==1);
+			FQ_VERIFY(cipher->crypt(cipher, buffer_data(input), buffer_data(input), cipher->blkSize)==1);
       }
     } else {
       // last_expected_input_length_ != 0
@@ -152,7 +152,7 @@ void FQTermSSH2PacketReceiver::parseData(FQTermSSHBuffer *input) {
       // so it must not be decrypted again.
     }
 
-    int packet_len = ntohu32(input->data());
+    int packet_len = ntohu32(buffer_data(input));
 
     if (packet_len > SSH_BUFFER_MAX) {
       emit packetError(tr("parseData: packet too big"));
@@ -161,7 +161,7 @@ void FQTermSSH2PacketReceiver::parseData(FQTermSSHBuffer *input) {
 
     int expected_input_len = 4 + packet_len + (is_mac_ ? mac->dgstSize : 0);
 
-    if (input->len()  < (long)expected_input_len) {
+    if (buffer_len(input)  < (long)expected_input_len) {
       FQ_TRACE("ssh2packet", 3)
           << "The packet is too small. Wait for more data.";
       last_expected_input_length_ = expected_input_len;    
@@ -173,7 +173,7 @@ void FQTermSSH2PacketReceiver::parseData(FQTermSSHBuffer *input) {
     // 2. decrypte data.
     if (is_decrypt_) {
       // decrypte blocks left.
-      unsigned char *tmp = input->data() + cipher->blkSize;
+      unsigned char *tmp = buffer_data(input) + cipher->blkSize;
       int left_len = expected_input_len - cipher->blkSize - mac->dgstSize;
       FQ_VERIFY(cipher->crypt(cipher, tmp, tmp, left_len)==1);
     }
@@ -186,12 +186,12 @@ void FQTermSSH2PacketReceiver::parseData(FQTermSSHBuffer *input) {
 	    buffer mbuf;
 	    buffer_init(&mbuf);
 	    buffer_append_be32(&mbuf, sequence_no_);
-	    buffer_append(&mbuf, (const uint8_t*)input->data(),
+	    buffer_append(&mbuf, (const uint8_t*)buffer_data(input),
 			    expected_input_len - digest_len);
 	    mac->getmac(mac, buffer_data(&mbuf), buffer_len(&mbuf), digest);
 	    buffer_deinit(&mbuf);
 
-	    u_char *received_digest = input->data() + expected_input_len - digest_len;
+	    u_char *received_digest = buffer_data(input) + expected_input_len - digest_len;
 
 	    if (memcmp(digest, received_digest, digest_len) != 0) {
 		    emit packetError("incorrect MAC.");
@@ -200,13 +200,13 @@ void FQTermSSH2PacketReceiver::parseData(FQTermSSHBuffer *input) {
     }
 
     // 4. get every field of the ssh packet.
-    packet_len = input->getInt();
+    packet_len = buffer_get_u32(input);
 
     std::vector<u_char> data(packet_len);
 
-    input->getRawData((char*)&data[0], packet_len);
+    buffer_get(input, &data[0], packet_len);
     if (is_mac_)
-      input->consume(mac->dgstSize);
+      buffer_consume(input, mac->dgstSize);
 
     int padding_len = data[0];
 
diff --git a/src/protocol/internal/fqterm_ssh2_packet.h b/src/protocol/internal/fqterm_ssh2_packet.h
index 7c7bf63..ff65ec5 100644
--- a/src/protocol/internal/fqterm_ssh2_packet.h
+++ b/src/protocol/internal/fqterm_ssh2_packet.h
@@ -40,7 +40,7 @@ private:
 public:
 FQTermSSH2PacketReceiver() : last_expected_input_length_(0)	{ }
 
-	virtual void parseData(FQTermSSHBuffer *input);
+	virtual void parseData(buffer *input);
 };
 
 }  // namespace FQTerm
diff --git a/src/protocol/internal/fqterm_ssh_packet.h b/src/protocol/internal/fqterm_ssh_packet.h
index 32f9a29..edc031f 100644
--- a/src/protocol/internal/fqterm_ssh_packet.h
+++ b/src/protocol/internal/fqterm_ssh_packet.h
@@ -109,7 +109,7 @@ class FQTermSSHPacketReceiver: public QObject {
   virtual int getKeySize() const { return cipher->keySize;}
   int getMacKeySize() const { return mac->keySize;}
 
-  virtual void parseData(FQTermSSHBuffer *input) = 0;
+  virtual void parseData(buffer *input) = 0;
  public slots:
   void startEncryption(const u_char *key, const u_char *IV = NULL);
   void resetEncryption();