~ubuntu-branches/ubuntu/lucid/openssh/lucid

/* $OpenBSD: sftp-client.c,v 1.86 2008/06/26 06:10:09 djm Exp $ */

/*

 * Copyright (c) 2001-2004 Damien Miller <djm@openbsd.org>

 *

 * Permission to use, copy, modify, and distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 */

/* XXX: memleaks */

/* XXX: signed vs unsigned */

/* XXX: remove all logging, only return status codes */

/* XXX: copy between two remote sites */

#include "includes.h"

#include <sys/types.h>

#include <sys/param.h>

#ifdef HAVE_SYS_STATVFS_H

#include <sys/statvfs.h>

#endif

#include "openbsd-compat/sys-queue.h"

#ifdef HAVE_SYS_STAT_H

# include <sys/stat.h>

#endif

#ifdef HAVE_SYS_TIME_H

# include <sys/time.h>

#endif

#include <sys/uio.h>

#include <errno.h>

#include <fcntl.h>

#include <signal.h>

#include <stdarg.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include "xmalloc.h"

#include "buffer.h"

#include "log.h"

#include "atomicio.h"

#include "progressmeter.h"

#include "misc.h"

#include "sftp.h"

#include "sftp-common.h"

#include "sftp-client.h"

extern volatile sig_atomic_t interrupted;

extern int showprogress;

/* Minimum amount of data to read at a time */

#define MIN_READ_SIZE	512

struct sftp_conn {

	int fd_in;

	int fd_out;

	u_int transfer_buflen;

	u_int num_requests;

	u_int version;

	u_int msg_id;

#define SFTP_EXT_POSIX_RENAME	0x00000001

#define SFTP_EXT_STATVFS	0x00000002

#define SFTP_EXT_FSTATVFS	0x00000004

	u_int exts;

};

static void

send_msg(int fd, Buffer *m)

{

	u_char mlen[4];

	struct iovec iov[2];

	if (buffer_len(m) > SFTP_MAX_MSG_LENGTH)

		fatal("Outbound message too long %u", buffer_len(m));

	/* Send length first */

	put_u32(mlen, buffer_len(m));

	iov[0].iov_base = mlen;

	iov[0].iov_len = sizeof(mlen);

	iov[1].iov_base = buffer_ptr(m);

	iov[1].iov_len = buffer_len(m);

	if (atomiciov(writev, fd, iov, 2) != buffer_len(m) + sizeof(mlen))

		fatal("Couldn't send packet: %s", strerror(errno));

	buffer_clear(m);

}

static void

get_msg(int fd, Buffer *m)

{

	u_int msg_len;

	buffer_append_space(m, 4);

	if (atomicio(read, fd, buffer_ptr(m), 4) != 4) {

		if (errno == EPIPE)

			fatal("Connection closed");

		else

			fatal("Couldn't read packet: %s", strerror(errno));

	}

	msg_len = buffer_get_int(m);

	if (msg_len > SFTP_MAX_MSG_LENGTH)

		fatal("Received message too long %u", msg_len);

	buffer_append_space(m, msg_len);

	if (atomicio(read, fd, buffer_ptr(m), msg_len) != msg_len) {

		if (errno == EPIPE)

			fatal("Connection closed");

		else

			fatal("Read packet: %s", strerror(errno));

	}

}

static void

send_string_request(int fd, u_int id, u_int code, char *s,

    u_int len)

{

	Buffer msg;

	buffer_init(&msg);

	buffer_put_char(&msg, code);

	buffer_put_int(&msg, id);

	buffer_put_string(&msg, s, len);

	send_msg(fd, &msg);

	debug3("Sent message fd %d T:%u I:%u", fd, code, id);

	buffer_free(&msg);

}

static void

send_string_attrs_request(int fd, u_int id, u_int code, char *s,

    u_int len, Attrib *a)

{

	Buffer msg;

	buffer_init(&msg);

	buffer_put_char(&msg, code);

	buffer_put_int(&msg, id);

	buffer_put_string(&msg, s, len);

	encode_attrib(&msg, a);

	send_msg(fd, &msg);

	debug3("Sent message fd %d T:%u I:%u", fd, code, id);

	buffer_free(&msg);

}

static u_int

get_status(int fd, u_int expected_id)

{

	Buffer msg;

	u_int type, id, status;

	buffer_init(&msg);

	get_msg(fd, &msg);

	type = buffer_get_char(&msg);

	id = buffer_get_int(&msg);

	if (id != expected_id)

		fatal("ID mismatch (%u != %u)", id, expected_id);

	if (type != SSH2_FXP_STATUS)

		fatal("Expected SSH2_FXP_STATUS(%u) packet, got %u",

		    SSH2_FXP_STATUS, type);

	status = buffer_get_int(&msg);

	buffer_free(&msg);

	debug3("SSH2_FXP_STATUS %u", status);

	return(status);

}

static char *

get_handle(int fd, u_int expected_id, u_int *len)

{

	Buffer msg;

	u_int type, id;

	char *handle;

	buffer_init(&msg);

	get_msg(fd, &msg);

	type = buffer_get_char(&msg);

	id = buffer_get_int(&msg);

	if (id != expected_id)

		fatal("ID mismatch (%u != %u)", id, expected_id);

	if (type == SSH2_FXP_STATUS) {

		int status = buffer_get_int(&msg);

		error("Couldn't get handle: %s", fx2txt(status));

		buffer_free(&msg);

		return(NULL);

	} else if (type != SSH2_FXP_HANDLE)

		fatal("Expected SSH2_FXP_HANDLE(%u) packet, got %u",

		    SSH2_FXP_HANDLE, type);

	handle = buffer_get_string(&msg, len);

	buffer_free(&msg);

	return(handle);

}

static Attrib *

get_decode_stat(int fd, u_int expected_id, int quiet)

{

	Buffer msg;

	u_int type, id;

	Attrib *a;

	buffer_init(&msg);

	get_msg(fd, &msg);

	type = buffer_get_char(&msg);

	id = buffer_get_int(&msg);

	debug3("Received stat reply T:%u I:%u", type, id);

	if (id != expected_id)

		fatal("ID mismatch (%u != %u)", id, expected_id);

	if (type == SSH2_FXP_STATUS) {

		int status = buffer_get_int(&msg);

		if (quiet)

			debug("Couldn't stat remote file: %s", fx2txt(status));

		else

			error("Couldn't stat remote file: %s", fx2txt(status));

		buffer_free(&msg);

		return(NULL);

	} else if (type != SSH2_FXP_ATTRS) {

		fatal("Expected SSH2_FXP_ATTRS(%u) packet, got %u",

		    SSH2_FXP_ATTRS, type);

	}

	a = decode_attrib(&msg);

	buffer_free(&msg);

	return(a);

}

static int

get_decode_statvfs(int fd, struct sftp_statvfs *st, u_int expected_id,

    int quiet)

{

	Buffer msg;

	u_int type, id, flag;

	buffer_init(&msg);

	get_msg(fd, &msg);

	type = buffer_get_char(&msg);

	id = buffer_get_int(&msg);

	debug3("Received statvfs reply T:%u I:%u", type, id);

	if (id != expected_id)

		fatal("ID mismatch (%u != %u)", id, expected_id);

	if (type == SSH2_FXP_STATUS) {

		int status = buffer_get_int(&msg);

		if (quiet)

			debug("Couldn't statvfs: %s", fx2txt(status));

		else

			error("Couldn't statvfs: %s", fx2txt(status));

		buffer_free(&msg);

		return -1;

	} else if (type != SSH2_FXP_EXTENDED_REPLY) {

		fatal("Expected SSH2_FXP_EXTENDED_REPLY(%u) packet, got %u",

		    SSH2_FXP_EXTENDED_REPLY, type);

	}

	bzero(st, sizeof(*st));

	st->f_bsize = buffer_get_int64(&msg);

	st->f_frsize = buffer_get_int64(&msg);

	st->f_blocks = buffer_get_int64(&msg);

	st->f_bfree = buffer_get_int64(&msg);

	st->f_bavail = buffer_get_int64(&msg);

	st->f_files = buffer_get_int64(&msg);

	st->f_ffree = buffer_get_int64(&msg);

	st->f_favail = buffer_get_int64(&msg);

	st->f_fsid = buffer_get_int64(&msg);

	flag = buffer_get_int64(&msg);

	st->f_namemax = buffer_get_int64(&msg);

	st->f_flag = (flag & SSH2_FXE_STATVFS_ST_RDONLY) ? ST_RDONLY : 0;

	st->f_flag |= (flag & SSH2_FXE_STATVFS_ST_NOSUID) ? ST_NOSUID : 0;

	buffer_free(&msg);

	return 0;

}

struct sftp_conn *

do_init(int fd_in, int fd_out, u_int transfer_buflen, u_int num_requests)

{

	u_int type, exts = 0;

	int version;

	Buffer msg;

	struct sftp_conn *ret;

	buffer_init(&msg);

	buffer_put_char(&msg, SSH2_FXP_INIT);

	buffer_put_int(&msg, SSH2_FILEXFER_VERSION);

	send_msg(fd_out, &msg);

	buffer_clear(&msg);

	get_msg(fd_in, &msg);

	/* Expecting a VERSION reply */

	if ((type = buffer_get_char(&msg)) != SSH2_FXP_VERSION) {

		error("Invalid packet back from SSH2_FXP_INIT (type %u)",

		    type);

		buffer_free(&msg);

		return(NULL);

	}

	version = buffer_get_int(&msg);

	debug2("Remote version: %d", version);

	/* Check for extensions */

	while (buffer_len(&msg) > 0) {

		char *name = buffer_get_string(&msg, NULL);

		char *value = buffer_get_string(&msg, NULL);

		int known = 0;

		if (strcmp(name, "posix-rename@openssh.com") == 0 &&

		    strcmp(value, "1") == 0) {

			exts |= SFTP_EXT_POSIX_RENAME;

			known = 1;

		} else if (strcmp(name, "statvfs@openssh.com") == 0 &&

		    strcmp(value, "2") == 0) {

			exts |= SFTP_EXT_STATVFS;

			known = 1;

		} if (strcmp(name, "fstatvfs@openssh.com") == 0 &&

		    strcmp(value, "2") == 0) {

			exts |= SFTP_EXT_FSTATVFS;

			known = 1;

		}

		if (known) {

			debug2("Server supports extension \"%s\" revision %s",

			    name, value);

		} else {

			debug2("Unrecognised server extension \"%s\"", name);

		}

		xfree(name);

		xfree(value);

	}

	buffer_free(&msg);

	ret = xmalloc(sizeof(*ret));

	ret->fd_in = fd_in;

	ret->fd_out = fd_out;

	ret->transfer_buflen = transfer_buflen;

	ret->num_requests = num_requests;

	ret->version = version;

	ret->msg_id = 1;

	ret->exts = exts;

	/* Some filexfer v.0 servers don't support large packets */

	if (version == 0)

		ret->transfer_buflen = MIN(ret->transfer_buflen, 20480);

	return(ret);

}

u_int

sftp_proto_version(struct sftp_conn *conn)

{

	return(conn->version);

}

int

do_close(struct sftp_conn *conn, char *handle, u_int handle_len)

{

	u_int id, status;

	Buffer msg;

	buffer_init(&msg);

	id = conn->msg_id++;

	buffer_put_char(&msg, SSH2_FXP_CLOSE);

	buffer_put_int(&msg, id);

	buffer_put_string(&msg, handle, handle_len);

	send_msg(conn->fd_out, &msg);

	debug3("Sent message SSH2_FXP_CLOSE I:%u", id);

	status = get_status(conn->fd_in, id);

	if (status != SSH2_FX_OK)

		error("Couldn't close file: %s", fx2txt(status));

	buffer_free(&msg);

	return(status);

}

static int

do_lsreaddir(struct sftp_conn *conn, char *path, int printflag,

    SFTP_DIRENT ***dir)

{

	Buffer msg;

	u_int count, type, id, handle_len, i, expected_id, ents = 0;

	char *handle;

	id = conn->msg_id++;

	buffer_init(&msg);

	buffer_put_char(&msg, SSH2_FXP_OPENDIR);

	buffer_put_int(&msg, id);

	buffer_put_cstring(&msg, path);

	send_msg(conn->fd_out, &msg);

	buffer_clear(&msg);

	handle = get_handle(conn->fd_in, id, &handle_len);

	if (handle == NULL)

		return(-1);

	if (dir) {

		ents = 0;

		*dir = xmalloc(sizeof(**dir));

		(*dir)[0] = NULL;

	}

	for (; !interrupted;) {

		id = expected_id = conn->msg_id++;

		debug3("Sending SSH2_FXP_READDIR I:%u", id);

		buffer_clear(&msg);

		buffer_put_char(&msg, SSH2_FXP_READDIR);

		buffer_put_int(&msg, id);

		buffer_put_string(&msg, handle, handle_len);

		send_msg(conn->fd_out, &msg);

		buffer_clear(&msg);

		get_msg(conn->fd_in, &msg);

		type = buffer_get_char(&msg);

		id = buffer_get_int(&msg);

		debug3("Received reply T:%u I:%u", type, id);

		if (id != expected_id)

			fatal("ID mismatch (%u != %u)", id, expected_id);

		if (type == SSH2_FXP_STATUS) {

			int status = buffer_get_int(&msg);

			debug3("Received SSH2_FXP_STATUS %d", status);

			if (status == SSH2_FX_EOF) {

				break;

			} else {

				error("Couldn't read directory: %s",

				    fx2txt(status));

				do_close(conn, handle, handle_len);

				xfree(handle);

				return(status);

			}

		} else if (type != SSH2_FXP_NAME)

			fatal("Expected SSH2_FXP_NAME(%u) packet, got %u",

			    SSH2_FXP_NAME, type);

		count = buffer_get_int(&msg);

		if (count == 0)

			break;

		debug3("Received %d SSH2_FXP_NAME responses", count);

		for (i = 0; i < count; i++) {

			char *filename, *longname;

			Attrib *a;

			filename = buffer_get_string(&msg, NULL);

			longname = buffer_get_string(&msg, NULL);

			a = decode_attrib(&msg);

			if (printflag)

				printf("%s\n", longname);

			if (dir) {

				*dir = xrealloc(*dir, ents + 2, sizeof(**dir));

				(*dir)[ents] = xmalloc(sizeof(***dir));

				(*dir)[ents]->filename = xstrdup(filename);

				(*dir)[ents]->longname = xstrdup(longname);

				memcpy(&(*dir)[ents]->a, a, sizeof(*a));

				(*dir)[++ents] = NULL;

			}

			xfree(filename);

			xfree(longname);

		}

	}

	buffer_free(&msg);

	do_close(conn, handle, handle_len);

	xfree(handle);

	/* Don't return partial matches on interrupt */

	if (interrupted && dir != NULL && *dir != NULL) {

		free_sftp_dirents(*dir);

		*dir = xmalloc(sizeof(**dir));

		**dir = NULL;

	}

	return(0);

}

int

do_readdir(struct sftp_conn *conn, char *path, SFTP_DIRENT ***dir)

{

	return(do_lsreaddir(conn, path, 0, dir));

}

void free_sftp_dirents(SFTP_DIRENT **s)

{

	int i;

	for (i = 0; s[i]; i++) {

		xfree(s[i]->filename);

		xfree(s[i]->longname);

		xfree(s[i]);

	}

	xfree(s);

}

int

do_rm(struct sftp_conn *conn, char *path)

{

	u_int status, id;

	debug2("Sending SSH2_FXP_REMOVE \"%s\"", path);

	id = conn->msg_id++;

	send_string_request(conn->fd_out, id, SSH2_FXP_REMOVE, path,

	    strlen(path));

	status = get_status(conn->fd_in, id);

	if (status != SSH2_FX_OK)

		error("Couldn't delete file: %s", fx2txt(status));

	return(status);

}

int

do_mkdir(struct sftp_conn *conn, char *path, Attrib *a)

{

	u_int status, id;

	id = conn->msg_id++;

	send_string_attrs_request(conn->fd_out, id, SSH2_FXP_MKDIR, path,

	    strlen(path), a);

	status = get_status(conn->fd_in, id);

	if (status != SSH2_FX_OK)

		error("Couldn't create directory: %s", fx2txt(status));

	return(status);

}

int

do_rmdir(struct sftp_conn *conn, char *path)

{

	u_int status, id;

	id = conn->msg_id++;

	send_string_request(conn->fd_out, id, SSH2_FXP_RMDIR, path,

	    strlen(path));

	status = get_status(conn->fd_in, id);

	if (status != SSH2_FX_OK)

		error("Couldn't remove directory: %s", fx2txt(status));

	return(status);

}

Attrib *

do_stat(struct sftp_conn *conn, char *path, int quiet)

{

	u_int id;

	id = conn->msg_id++;

	send_string_request(conn->fd_out, id,

	    conn->version == 0 ? SSH2_FXP_STAT_VERSION_0 : SSH2_FXP_STAT,

	    path, strlen(path));

	return(get_decode_stat(conn->fd_in, id, quiet));

}

Attrib *

do_lstat(struct sftp_conn *conn, char *path, int quiet)

{

	u_int id;

	if (conn->version == 0) {

		if (quiet)

			debug("Server version does not support lstat operation");

		else

			logit("Server version does not support lstat operation");

		return(do_stat(conn, path, quiet));

	}

	id = conn->msg_id++;

	send_string_request(conn->fd_out, id, SSH2_FXP_LSTAT, path,

	    strlen(path));

	return(get_decode_stat(conn->fd_in, id, quiet));

}

#ifdef notyet

Attrib *

do_fstat(struct sftp_conn *conn, char *handle, u_int handle_len, int quiet)

{

	u_int id;

	id = conn->msg_id++;

	send_string_request(conn->fd_out, id, SSH2_FXP_FSTAT, handle,

	    handle_len);

	return(get_decode_stat(conn->fd_in, id, quiet));

}

#endif

int

do_setstat(struct sftp_conn *conn, char *path, Attrib *a)

{

	u_int status, id;

	id = conn->msg_id++;

	send_string_attrs_request(conn->fd_out, id, SSH2_FXP_SETSTAT, path,

	    strlen(path), a);

	status = get_status(conn->fd_in, id);

	if (status != SSH2_FX_OK)

		error("Couldn't setstat on \"%s\": %s", path,

		    fx2txt(status));

	return(status);

}

int

do_fsetstat(struct sftp_conn *conn, char *handle, u_int handle_len,

    Attrib *a)

{

	u_int status, id;

	id = conn->msg_id++;

	send_string_attrs_request(conn->fd_out, id, SSH2_FXP_FSETSTAT, handle,

	    handle_len, a);

	status = get_status(conn->fd_in, id);

	if (status != SSH2_FX_OK)

		error("Couldn't fsetstat: %s", fx2txt(status));

	return(status);

}

char *

do_realpath(struct sftp_conn *conn, char *path)

{

	Buffer msg;

	u_int type, expected_id, count, id;

	char *filename, *longname;

	Attrib *a;

	expected_id = id = conn->msg_id++;

	send_string_request(conn->fd_out, id, SSH2_FXP_REALPATH, path,

	    strlen(path));

	buffer_init(&msg);

	get_msg(conn->fd_in, &msg);

	type = buffer_get_char(&msg);

	id = buffer_get_int(&msg);

	if (id != expected_id)

		fatal("ID mismatch (%u != %u)", id, expected_id);

	if (type == SSH2_FXP_STATUS) {

		u_int status = buffer_get_int(&msg);

		error("Couldn't canonicalise: %s", fx2txt(status));

		return(NULL);

	} else if (type != SSH2_FXP_NAME)

		fatal("Expected SSH2_FXP_NAME(%u) packet, got %u",

		    SSH2_FXP_NAME, type);

	count = buffer_get_int(&msg);

	if (count != 1)

		fatal("Got multiple names (%d) from SSH_FXP_REALPATH", count);

	filename = buffer_get_string(&msg, NULL);

	longname = buffer_get_string(&msg, NULL);

	a = decode_attrib(&msg);

	debug3("SSH_FXP_REALPATH %s -> %s", path, filename);

	xfree(longname);

	buffer_free(&msg);

	return(filename);

}

int

do_rename(struct sftp_conn *conn, char *oldpath, char *newpath)

{

	Buffer msg;

	u_int status, id;

	buffer_init(&msg);

	/* Send rename request */

	id = conn->msg_id++;

	if ((conn->exts & SFTP_EXT_POSIX_RENAME)) {

		buffer_put_char(&msg, SSH2_FXP_EXTENDED);

		buffer_put_int(&msg, id);

		buffer_put_cstring(&msg, "posix-rename@openssh.com");

	} else {

		buffer_put_char(&msg, SSH2_FXP_RENAME);

		buffer_put_int(&msg, id);

	}

	buffer_put_cstring(&msg, oldpath);

	buffer_put_cstring(&msg, newpath);

	send_msg(conn->fd_out, &msg);

	debug3("Sent message %s \"%s\" -> \"%s\"",

	    (conn->exts & SFTP_EXT_POSIX_RENAME) ? "posix-rename@openssh.com" :