git.sesse.net Git - ffmpeg/blob - libavformat/libssh.c

   1 /*
   2  * Copyright (c) 2013 Lukasz Marek <lukasz.m.luki@gmail.com>
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <fcntl.h>
  22 #include <libssh/sftp.h>
  23 #include "libavutil/avstring.h"
  24 #include "libavutil/opt.h"
  25 #include "avformat.h"
  26 #include "internal.h"
  27 #include "url.h"
  28
  29 typedef struct {
  30     const AVClass *class;
  31     ssh_session session;
  32     sftp_session sftp;
  33     sftp_file file;
  34     int64_t filesize;
  35     int rw_timeout;
  36     int trunc;
  37 } LIBSSHContext;
  38
  39 static int libssh_close(URLContext *h)
  40 {
  41     LIBSSHContext *s = h->priv_data;
  42     if (s->file)
  43         sftp_close(s->file);
  44     if (s->sftp)
  45         sftp_free(s->sftp);
  46     if (s->session) {
  47         ssh_disconnect(s->session);
  48         ssh_free(s->session);
  49     }
  50     return 0;
  51 }
  52
  53 static int libssh_open(URLContext *h, const char *url, int flags)
  54 {
  55     static const int verbosity = SSH_LOG_NOLOG;
  56     LIBSSHContext *s = h->priv_data;
  57     char proto[10], path[MAX_URL_SIZE], hostname[1024], credencials[1024];
  58     int port = 22, access, ret;
  59     long timeout = s->rw_timeout * 1000;
  60     const char *user = NULL, *pass = NULL;
  61     char *end = NULL;
  62     sftp_attributes stat;
  63
  64     av_url_split(proto, sizeof(proto),
  65                  credencials, sizeof(credencials),
  66                  hostname, sizeof(hostname),
  67                  &port,
  68                  path, sizeof(path),
  69                  url);
  70
  71     if (port <= 0 || port > 65535)
  72         port = 22;
  73
  74     if (!(s->session = ssh_new())) {
  75         ret = AVERROR(ENOMEM);
  76         goto fail;
  77     }
  78     user = av_strtok(credencials, ":", &end);
  79     pass = av_strtok(end, ":", &end);
  80     ssh_options_set(s->session, SSH_OPTIONS_HOST, hostname);
  81     ssh_options_set(s->session, SSH_OPTIONS_PORT, &port);
  82     ssh_options_set(s->session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity);
  83     if (timeout > 0)
  84         ssh_options_set(s->session, SSH_OPTIONS_TIMEOUT_USEC, &timeout);
  85     if (user)
  86         ssh_options_set(s->session, SSH_OPTIONS_USER, user);
  87
  88     if (ssh_connect(s->session) != SSH_OK) {
  89         av_log(h, AV_LOG_ERROR, "Connection failed. %s\n", ssh_get_error(s->session));
  90         ret = AVERROR(EIO);
  91         goto fail;
  92     }
  93
  94     if (ssh_userauth_autopubkey(s->session, pass) != SSH_AUTH_SUCCESS) {
  95         av_log(s, AV_LOG_DEBUG, "Authentication using public key failed, trying password method.\n");
  96         if (ssh_userauth_password(s->session, NULL, pass) != SSH_AUTH_SUCCESS) {
  97             av_log(h, AV_LOG_ERROR, "Authentication failed.\n");
  98             ret = AVERROR(EACCES);
  99             goto fail;
 100         }
 101     }
 102
 103     if (!(s->sftp = sftp_new(s->session))) {
 104         av_log(h, AV_LOG_ERROR, "SFTP session creation failed: %s\n", ssh_get_error(s->session));
 105         ret = AVERROR(ENOMEM);
 106         goto fail;
 107     }
 108
 109     if (sftp_init(s->sftp) != SSH_OK) {
 110         av_log(h, AV_LOG_ERROR, "Error initializing sftp session: %s\n", ssh_get_error(s->session));
 111         ret = AVERROR(EIO);
 112         goto fail;
 113     }
 114
 115     if ((flags & AVIO_FLAG_WRITE) && (flags & AVIO_FLAG_READ)) {
 116         access = O_CREAT | O_RDWR;
 117         if (s->trunc)
 118             access |= O_TRUNC;
 119     } else if (flags & AVIO_FLAG_WRITE) {
 120         access = O_CREAT | O_WRONLY;
 121         if (s->trunc)
 122             access |= O_TRUNC;
 123     } else {
 124         access = O_RDONLY;
 125     }
 126
 127     /* 0666 = -rw-rw-rw- = read+write for everyone, minus umask */
 128     if (!(s->file = sftp_open(s->sftp, path, access, 0666))) {
 129         av_log(h, AV_LOG_ERROR, "Error opening sftp file: %s\n", ssh_get_error(s->session));
 130         ret = AVERROR(EIO);
 131         goto fail;
 132     }
 133
 134     if (!(stat = sftp_fstat(s->file))) {
 135         av_log(h, AV_LOG_WARNING, "Cannot stat remote file %s.\n", path);
 136         s->filesize = -1;
 137     } else {
 138         s->filesize = stat->size;
 139         sftp_attributes_free(stat);
 140     }
 141
 142     return 0;
 143
 144   fail:
 145     libssh_close(h);
 146     return ret;
 147 }
 148
 149 static int64_t libssh_seek(URLContext *h, int64_t pos, int whence)
 150 {
 151     LIBSSHContext *s = h->priv_data;
 152     int64_t newpos;
 153
 154     if (s->filesize == -1 && (whence == AVSEEK_SIZE || whence == SEEK_END)) {
 155         av_log(h, AV_LOG_ERROR, "Error during seeking.\n");
 156         return AVERROR(EIO);
 157     }
 158
 159     switch(whence) {
 160     case AVSEEK_SIZE:
 161         return s->filesize;
 162     case SEEK_SET:
 163         newpos = pos;
 164         break;
 165     case SEEK_CUR:
 166         newpos = sftp_tell64(s->file);
 167         break;
 168     case SEEK_END:
 169         newpos = s->filesize + pos;
 170         break;
 171     default:
 172         return AVERROR(EINVAL);
 173     }
 174
 175     if (sftp_seek64(s->file, newpos)) {
 176         av_log(h, AV_LOG_ERROR, "Error during seeking.\n");
 177         return AVERROR(EIO);
 178     }
 179
 180     return newpos;
 181 }
 182
 183 static int libssh_read(URLContext *h, unsigned char *buf, int size)
 184 {
 185     LIBSSHContext *s = h->priv_data;
 186     int bytes_read;
 187
 188     if ((bytes_read = sftp_read(s->file, buf, size)) < 0) {
 189         av_log(h, AV_LOG_ERROR, "Read error.\n");
 190         return AVERROR(EIO);
 191     }
 192     return bytes_read;
 193 }
 194
 195 static int libssh_write(URLContext *h, const unsigned char *buf, int size)
 196 {
 197     LIBSSHContext *s = h->priv_data;
 198     int bytes_written;
 199
 200     if ((bytes_written = sftp_write(s->file, buf, size)) < 0) {
 201         av_log(h, AV_LOG_ERROR, "Write error.\n");
 202         return AVERROR(EIO);
 203     }
 204     return bytes_written;
 205 }
 206
 207 #define OFFSET(x) offsetof(LIBSSHContext, x)
 208 #define D AV_OPT_FLAG_DECODING_PARAM
 209 #define E AV_OPT_FLAG_ENCODING_PARAM
 210 static const AVOption options[] = {
 211     {"timeout", "set timeout of socket I/O operations", OFFSET(rw_timeout), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, D|E },
 212     {"truncate", "Truncate existing files on write", OFFSET(trunc), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, E },
 213     {NULL}
 214 };
 215
 216 static const AVClass libssh_context_class = {
 217     .class_name     = "libssh",
 218     .item_name      = av_default_item_name,
 219     .option         = options,
 220     .version        = LIBAVUTIL_VERSION_INT,
 221 };
 222
 223 URLProtocol ff_libssh_protocol = {
 224     .name                = "sftp",
 225     .url_open            = libssh_open,
 226     .url_read            = libssh_read,
 227     .url_write           = libssh_write,
 228     .url_seek            = libssh_seek,
 229     .url_close           = libssh_close,
 230     .priv_data_size      = sizeof(LIBSSHContext),
 231     .priv_data_class     = &libssh_context_class,
 232     .flags               = URL_PROTOCOL_FLAG_NETWORK,
 233 };