mirror of
https://git.tartarus.org/simon/putty.git
synced 2025-01-09 17:38:00 +00:00
e0a76971cc
The idea of these is that they centralise the common idiom along the
lines of
if (logical_array_len >= physical_array_size) {
physical_array_size = logical_array_len * 5 / 4 + 256;
array = sresize(array, physical_array_size, ElementType);
}
which happens at a zillion call sites throughout this code base, with
different random choices of the geometric factor and additive
constant, sometimes forgetting them completely, and generally doing a
lot of repeated work.
The new macro sgrowarray(array,size,n) has the semantics: here are the
array pointer and its physical size for you to modify, now please
ensure that the nth element exists, so I can write into it. And
sgrowarrayn(array,size,n,m) is the same except that it ensures that
the array has size at least n+m (so sgrowarray is just the special
case where m=1).
Now that this is a single centralised implementation that will be used
everywhere, I've also gone to more effort in the implementation, with
careful overflow checks that would have been painful to put at all the
previous call sites.
This commit also switches over every use of sresize(), apart from a
few where I really didn't think it would gain anything. A consequence
of that is that a lot of array-size variables have to have their types
changed to size_t, because the macros require that (they address-take
the size to pass to the underlying function).
134 lines
3.3 KiB
C
134 lines
3.3 KiB
C
/*
|
|
* sftpcommon.c: SFTP code shared between client and server.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <limits.h>
|
|
|
|
#include "misc.h"
|
|
#include "sftp.h"
|
|
|
|
static void sftp_pkt_BinarySink_write(
|
|
BinarySink *bs, const void *data, size_t length)
|
|
{
|
|
struct sftp_packet *pkt = BinarySink_DOWNCAST(bs, struct sftp_packet);
|
|
|
|
assert(length <= 0xFFFFFFFFU - pkt->length);
|
|
|
|
sgrowarrayn(pkt->data, pkt->maxlen, pkt->length, length);
|
|
memcpy(pkt->data + pkt->length, data, length);
|
|
pkt->length += length;
|
|
}
|
|
|
|
struct sftp_packet *sftp_pkt_init(int type)
|
|
{
|
|
struct sftp_packet *pkt;
|
|
pkt = snew(struct sftp_packet);
|
|
pkt->data = NULL;
|
|
pkt->savedpos = -1;
|
|
pkt->length = 0;
|
|
pkt->maxlen = 0;
|
|
pkt->type = type;
|
|
BinarySink_INIT(pkt, sftp_pkt_BinarySink_write);
|
|
put_uint32(pkt, 0); /* length field will be filled in later */
|
|
put_byte(pkt, 0); /* so will the type field */
|
|
return pkt;
|
|
}
|
|
|
|
void BinarySink_put_fxp_attrs(BinarySink *bs, struct fxp_attrs attrs)
|
|
{
|
|
put_uint32(bs, attrs.flags);
|
|
if (attrs.flags & SSH_FILEXFER_ATTR_SIZE)
|
|
put_uint64(bs, attrs.size);
|
|
if (attrs.flags & SSH_FILEXFER_ATTR_UIDGID) {
|
|
put_uint32(bs, attrs.uid);
|
|
put_uint32(bs, attrs.gid);
|
|
}
|
|
if (attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS) {
|
|
put_uint32(bs, attrs.permissions);
|
|
}
|
|
if (attrs.flags & SSH_FILEXFER_ATTR_ACMODTIME) {
|
|
put_uint32(bs, attrs.atime);
|
|
put_uint32(bs, attrs.mtime);
|
|
}
|
|
if (attrs.flags & SSH_FILEXFER_ATTR_EXTENDED) {
|
|
/*
|
|
* We currently don't support sending any extended
|
|
* attributes.
|
|
*/
|
|
}
|
|
}
|
|
|
|
const struct fxp_attrs no_attrs = { 0 };
|
|
|
|
#define put_fxp_attrs(bs, attrs) \
|
|
BinarySink_put_fxp_attrs(BinarySink_UPCAST(bs), attrs)
|
|
|
|
bool BinarySource_get_fxp_attrs(BinarySource *src, struct fxp_attrs *attrs)
|
|
{
|
|
attrs->flags = get_uint32(src);
|
|
if (attrs->flags & SSH_FILEXFER_ATTR_SIZE)
|
|
attrs->size = get_uint64(src);
|
|
if (attrs->flags & SSH_FILEXFER_ATTR_UIDGID) {
|
|
attrs->uid = get_uint32(src);
|
|
attrs->gid = get_uint32(src);
|
|
}
|
|
if (attrs->flags & SSH_FILEXFER_ATTR_PERMISSIONS)
|
|
attrs->permissions = get_uint32(src);
|
|
if (attrs->flags & SSH_FILEXFER_ATTR_ACMODTIME) {
|
|
attrs->atime = get_uint32(src);
|
|
attrs->mtime = get_uint32(src);
|
|
}
|
|
if (attrs->flags & SSH_FILEXFER_ATTR_EXTENDED) {
|
|
unsigned long count = get_uint32(src);
|
|
while (count--) {
|
|
/*
|
|
* We should try to analyse these, if we ever find one
|
|
* we recognise.
|
|
*/
|
|
get_string(src);
|
|
get_string(src);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void sftp_pkt_free(struct sftp_packet *pkt)
|
|
{
|
|
if (pkt->data)
|
|
sfree(pkt->data);
|
|
sfree(pkt);
|
|
}
|
|
|
|
void sftp_send_prepare(struct sftp_packet *pkt)
|
|
{
|
|
PUT_32BIT_MSB_FIRST(pkt->data, pkt->length - 4);
|
|
if (pkt->length >= 5) {
|
|
/* Rewrite the type code, in case the caller changed its mind
|
|
* about pkt->type since calling sftp_pkt_init */
|
|
pkt->data[4] = pkt->type;
|
|
}
|
|
}
|
|
|
|
struct sftp_packet *sftp_recv_prepare(unsigned length)
|
|
{
|
|
struct sftp_packet *pkt;
|
|
|
|
pkt = snew(struct sftp_packet);
|
|
pkt->savedpos = 0;
|
|
pkt->length = pkt->maxlen = length;
|
|
pkt->data = snewn(pkt->length, char);
|
|
|
|
return pkt;
|
|
}
|
|
|
|
bool sftp_recv_finish(struct sftp_packet *pkt)
|
|
{
|
|
BinarySource_INIT(pkt, pkt->data, pkt->length);
|
|
pkt->type = get_byte(pkt);
|
|
return !get_err(pkt);
|
|
}
|