First real benchmark : raw SSH speed

tests/benchmarks/bench_raw.c

@@ -0,0 +1,182 @@
+/*
+ * This file is part of the SSH Library
+ *
+ * Copyright (c) 2010 by Aris Adamantiadis
+ *
+ * The SSH Library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at your
+ * option) any later version.
+ *
+ * The SSH Library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with the SSH Library; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+
+#include "benchmarks.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define PYTHON_PATH "/usr/bin/python"
+
+const char python_eater[]=
+"#!/usr/bin/python\n"
+"import sys\n"
+"print 'go'\n"
+"sys.stdout.flush()\n"
+"toread=XXXXXXXXXX\n"
+"read=0\n"
+"while(read < toread):\n"
+"    buffersize=toread-read\n"
+"    if(buffersize > 4096):\n"
+"        buffersize=4096\n"
+"    r=len(sys.stdin.read(buffersize))\n"
+"    read+=r\n"
+"    if(r<=0):\n"
+"        print 'error'\n"
+"        exit()\n"
+"print 'done'\n";
+
+static char *get_python_eater(unsigned long bytes){
+  char *eater=malloc(sizeof(python_eater));
+  char *ptr;
+  char buffer[12];
+
+  memcpy(eater,python_eater,sizeof(python_eater));
+  ptr=strstr(eater,"XXXXXXXXXX");
+  if(!ptr){
+    free(eater);
+    return NULL;
+  }
+  sprintf(buffer,"0x%.8lx",bytes);
+  memcpy(ptr,buffer,10);
+  return eater;
+}
+
+/** @internal
+ * @brief uploads a script (python or other) at a specific path on the
+ * remote host
+ * @param[in] session an active SSH session
+ * @param[in] path to copy the file
+ * @param[in] content of the file to copy
+ * @return 0 on success, -1 on error
+ */
+static int upload_script(ssh_session session, const char *path,
+    const char *script){
+  ssh_channel channel;
+  char cmd[128];
+  int err;
+
+  channel=ssh_channel_new(session);
+  if(!channel)
+    goto error;
+  if(ssh_channel_open_session(channel) == SSH_ERROR)
+    goto error;
+  snprintf(cmd,sizeof(cmd),"cat > %s",path);
+  if(ssh_channel_request_exec(channel,cmd) == SSH_ERROR)
+    goto error;
+  err=ssh_channel_write(channel,script,strlen(script));
+  if(err == SSH_ERROR)
+    goto error;
+  if(ssh_channel_send_eof(channel) == SSH_ERROR)
+    goto error;
+  if(ssh_channel_close(channel) == SSH_ERROR)
+    goto error;
+  ssh_channel_free(channel);
+  return 0;
+error:
+  fprintf(stderr,"Error while copying script : %s\n",ssh_get_error(session));
+  return -1;
+}
+
+/** @internal
+ * @brief benchmarks a raw upload (simple upload in a SSH channel) using an
+ * existing SSH session.
+ * @param[in] session Open SSH session
+ * @param[in] args Parsed command line arguments
+ * @param[out] bps The calculated bytes per second obtained via benchmark.
+ * @return 0 on success, -1 on error.
+ */
+int benchmarks_raw_up (ssh_session session, struct argument_s *args,
+    float *bps){
+  unsigned long bytes=0x1000000;
+  char *script=get_python_eater(bytes);
+  char cmd[128];
+  char buffer[1024];
+  int err;
+  ssh_channel channel;
+  struct timestamp_struct ts;
+  float ms=0.0;
+  unsigned long total=0;
+  (void)bps;
+
+  err=upload_script(session,"/tmp/eater.py",script);
+  free(script);
+  if(err<0)
+    return err;
+  channel=ssh_channel_new(session);
+  if(channel == NULL)
+    goto error;
+  if(ssh_channel_open_session(channel)==SSH_ERROR)
+    goto error;
+  snprintf(cmd,sizeof(cmd),"%s /tmp/eater.py", PYTHON_PATH);
+  if(ssh_channel_request_exec(channel,cmd)==SSH_ERROR)
+    goto error;
+  if((err=ssh_channel_read(channel,buffer,sizeof(buffer)-1,0))==SSH_ERROR)
+    goto error;
+  buffer[err]=0;
+  if(!strstr(buffer,"go")){
+    fprintf(stderr,"parse error : %s\n",buffer);
+    ssh_channel_close(channel);
+    ssh_channel_free(channel);
+    return -1;
+  }
+  if(args->verbose>0)
+    fprintf(stdout,"Starting upload of %lu bytes now\n",bytes);
+  timestamp_init(&ts);
+  while(total < bytes){
+    unsigned long towrite = bytes - total;
+    int w;
+    if(towrite > 0x1000)
+      towrite = 0x1000;
+    w=ssh_channel_write(channel,buffer,towrite);
+    if(w == SSH_ERROR)
+      goto error;
+    total += w;
+  }
+
+  if(args->verbose>0)
+    fprintf(stdout,"Finished upload, now waiting the ack\n");
+
+  if((err=ssh_channel_read(channel,buffer,sizeof(buffer)-1,0))==SSH_ERROR)
+      goto error;
+  buffer[err]=0;
+  if(!strstr(buffer,"done")){
+    fprintf(stderr,"parse error : %s\n",buffer);
+    ssh_channel_close(channel);
+    ssh_channel_free(channel);
+    return -1;
+  }
+  ms=elapsed_time(&ts);
+  *bps=8000 * (float)bytes / ms;
+  if(args->verbose > 0)
+    fprintf(stdout,"Upload took %f ms for %lu bytes, at %f bps\n",ms,
+        bytes,*bps);
+  ssh_channel_close(channel);
+  ssh_channel_free(channel);
+  return 0;
+error:
+  fprintf(stderr,"Error during raw upload : %s\n",ssh_get_error(session));
+  if(channel){
+    ssh_channel_close(channel);
+    ssh_channel_free(channel);
+  }
+  return -1;
+}