example-sshpass.c

   1 /* miniexpect example.
   2  * Copyright (C) 2014-2022 Red Hat Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 /* There is a program called 'sshpass' which does roughly the same
  20  * as this simplified example.  We run ssh as a subprocess, and log
  21  * in using the given password from the command line.
  22  *
  23  * The first argument is the password to send at the password prompt.
  24  * The remaining arguments are passed to the ssh subprocess.
  25  *
  26  * For example:
  27  *   sshpass [-d] 123456 ssh remote.example.com
  28  *   sshpass [-d] 123456 ssh -l root remote.example.com
  29  *
  30  * Use the -d flag to enable debugging to stderr.
  31  */
  32
  33 #include <config.h>
  34
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <unistd.h>
  39 #include <assert.h>
  40
  41 #define PCRE2_CODE_UNIT_WIDTH 8
  42 #include <pcre2.h>
  43
  44 #include "miniexpect.h"
  45
  46 static pcre2_code *compile_re (const char *rex);
  47
  48 static void
  49 usage (void)
  50 {
  51   fprintf (stderr, "usage: sshpass [-d] PASSWORD ssh [SSH-ARGS...] HOST\n");
  52   exit (EXIT_FAILURE);
  53 }
  54
  55 int
  56 main (int argc, char *argv[])
  57 {
  58   int opt;
  59   int debug = 0;
  60   mexp_h *h;
  61   const char *password;
  62   int status;
  63   pcre2_code *password_re, *prompt_re, *hello_re;
  64   pcre2_match_data *match_data;
  65
  66   match_data = pcre2_match_data_create (4, NULL);
  67
  68   while ((opt = getopt (argc, argv, "d")) != -1) {
  69     switch (opt) {
  70     case 'd':
  71       debug = 1;
  72       break;
  73     default:
  74       usage ();
  75     }
  76   }
  77
  78   if (argc-optind <= 2)
  79     usage ();
  80
  81   password = argv[optind];
  82   optind++;
  83
  84   printf ("starting ssh command ...\n");
  85
  86   h = mexp_spawnv (argv[optind], &argv[optind]);
  87   if (h == NULL) {
  88     perror ("mexp_spawnv: ssh");
  89     exit (EXIT_FAILURE);
  90   }
  91   if (debug)
  92     mexp_set_debug_file (h, stderr);
  93
  94   /* Wait for the password prompt. */
  95   password_re = compile_re ("assword");
  96   switch (mexp_expect (h,
  97                        (mexp_regexp[]) {
  98                          { 100, .re = password_re },
  99                          { 0 }
 100                        },
 101                        match_data)) {
 102   case 100:
 103     break;
 104   case MEXP_EOF:
 105     fprintf (stderr, "error: ssh closed the connection unexpectedly\n");
 106     goto error;
 107   case MEXP_TIMEOUT:
 108     fprintf (stderr, "error: timeout before reaching the password prompt\n");
 109     goto error;
 110   case MEXP_ERROR:
 111     perror ("mexp_expect");
 112     goto error;
 113   case MEXP_PCRE_ERROR:
 114     fprintf (stderr, "error: PCRE error: %d\n", mexp_get_pcre_error (h));
 115     goto error;
 116   }
 117
 118   /* Got the password prompt, so send a password.
 119    *
 120    * Note use of mexp_printf_password here which is identical to
 121    * mexp_printf except that it hides the password in debugging
 122    * output.
 123    */
 124   printf ("sending the password ...\n");
 125
 126   if (mexp_printf_password (h, "%s", password) == -1 ||
 127       mexp_printf (h, "\n") == -1) {
 128     perror ("mexp_printf");
 129     goto error;
 130   }
 131
 132   /* We have to wait for the prompt before we can send commands
 133    * (because the ssh connection may not be fully established).  If we
 134    * get "password" again, then probably the password was wrong.  This
 135    * expect checks all these possibilities.  Unfortunately since all
 136    * prompts are a little bit different, we have to guess here.
 137    */
 138   prompt_re = compile_re ("[#$]");
 139   switch (mexp_expect (h,
 140                        (mexp_regexp[]) {
 141                          { 100, .re = password_re },
 142                          { 101, .re = prompt_re },
 143                          { 0 },
 144                        },
 145                        match_data)) {
 146   case 100:                     /* Password. */
 147     fprintf (stderr, "error: ssh asked for password again, probably the password supplied is wrong\n");
 148     goto error;
 149   case 101:                     /* Prompt. */
 150     break;
 151   case MEXP_EOF:
 152     fprintf (stderr, "error: ssh closed the connection unexpectedly\n");
 153     goto error;
 154   case MEXP_TIMEOUT:
 155     fprintf (stderr, "error: timeout before reaching the prompt\n");
 156     goto error;
 157   case MEXP_ERROR:
 158     perror ("mexp_expect");
 159     goto error;
 160   case MEXP_PCRE_ERROR:
 161     fprintf (stderr, "error: PCRE error: %d\n", mexp_get_pcre_error (h));
 162     goto error;
 163   }
 164
 165   /* Send a command which will have expected output. */
 166   printf ("sending a test command ...\n");
 167
 168   if (mexp_printf (h, "echo h''ello\n") == -1) {
 169     perror ("mexp_printf");
 170     goto error;
 171   }
 172
 173   /* Wait for expected output from echo hello command. */
 174   hello_re = compile_re ("hello");
 175   switch (mexp_expect (h,
 176                        (mexp_regexp[]) {
 177                          { 100, .re = hello_re },
 178                          { 0 },
 179                        },
 180                        match_data)) {
 181   case 100:
 182     break;
 183   case MEXP_EOF:
 184     fprintf (stderr, "error: ssh closed the connection unexpectedly\n");
 185     goto error;
 186   case MEXP_TIMEOUT:
 187     fprintf (stderr, "error: timeout before reading command output\n");
 188     goto error;
 189   case MEXP_ERROR:
 190     perror ("mexp_expect");
 191     goto error;
 192   case MEXP_PCRE_ERROR:
 193     fprintf (stderr, "error: PCRE error: %d\n", mexp_get_pcre_error (h));
 194     goto error;
 195   }
 196
 197   /* Send exit command and wait for ssh to exit. */
 198   printf ("sending the exit command ...\n");
 199
 200   if (mexp_printf (h, "exit\n") == -1) {
 201     perror ("mexp_printf");
 202     goto error;
 203   }
 204
 205   switch (mexp_expect (h, NULL, NULL)) {
 206   case MEXP_EOF:
 207     /* This is what we're expecting: ssh will close the connection. */
 208     break;
 209   case MEXP_TIMEOUT:
 210     fprintf (stderr, "error: timeout before ssh closed the connection\n");
 211     goto error;
 212   case MEXP_ERROR:
 213     perror ("mexp_expect");
 214     goto error;
 215   case MEXP_PCRE_ERROR:
 216     fprintf (stderr, "error: unexpected return value from mexp_expect\n");
 217     goto error;
 218   }
 219
 220   /* Close the ssh connection. */
 221   status = mexp_close (h);
 222   if (status != 0) {
 223     fprintf (stderr, "error: bad exit status from ssh subprocess (status=%d)\n",
 224              status);
 225     exit (EXIT_FAILURE);
 226   }
 227
 228   printf ("test was successful\n");
 229
 230   pcre2_match_data_free (match_data);
 231   exit (EXIT_SUCCESS);
 232
 233  error:
 234   mexp_close (h);
 235   exit (EXIT_FAILURE);
 236 }
 237
 238 /* Helper function to compile a PCRE regexp. */
 239 static pcre2_code *
 240 compile_re (const char *rex)
 241 {
 242   int errorcode;
 243   PCRE2_SIZE erroroffset;
 244   char errormsg[256];
 245   pcre2_code *ret;
 246
 247   ret = pcre2_compile ((PCRE2_SPTR) rex, PCRE2_ZERO_TERMINATED,
 248                        0, &errorcode, &erroroffset, NULL);
 249   if (ret == NULL) {
 250     pcre2_get_error_message (errorcode,
 251                              (PCRE2_UCHAR *) errormsg, sizeof errormsg);
 252     fprintf (stderr, "error: "
 253              "failed to compile regular expression '%s': "
 254              "%s at offset %zu\n",
 255              rex, errormsg, erroroffset);
 256     exit (EXIT_FAILURE);
 257   }
 258   return ret;
 259 }