mirror of
https://git.tartarus.org/simon/putty.git
synced 2025-01-09 17:38:00 +00:00
0e3082ee89
I've finally got tired of all the code throughout PuTTY that repeats the same logic about how to format the SSH binary primitives like uint32, string, mpint. We've got reasonably organised code in ssh.c that appends things like that to 'struct Packet'; something similar in sftp.c which repeats a lot of the work; utility functions in various places to format an mpint to feed to one or another hash function; and no end of totally ad-hoc stuff in functions like public key blob formatters which actually have to _count up_ the size of data painstakingly, then malloc exactly that much and mess about with PUT_32BIT. It's time to bring all of that into one place, and stop repeating myself in error-prone ways everywhere. The new marshal.h defines a system in which I centralise all the actual marshalling functions, and then layer a touch of C macro trickery on top to allow me to (look as if I) pass a wide range of different types to those functions, as long as the target type has been set up in the right way to have a write() function. This commit adds the new header and source file, and sets up some general centralised types (strbuf and the various hash-function contexts like SHA_State), but doesn't use the new calls for anything yet. (I've also renamed some internal functions in import.c which were using the same names that I've just defined macros over. That won't last long - those functions are going to go away soon, so the changed names are strictly temporary.)
80 lines
1.8 KiB
C
80 lines
1.8 KiB
C
#include <assert.h>
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
|
|
#include "marshal.h"
|
|
#include "misc.h"
|
|
#include "int64.h"
|
|
|
|
void BinarySink_put_data(BinarySink *bs, const void *data, size_t len)
|
|
{
|
|
bs->write(bs, data, len);
|
|
}
|
|
|
|
void BinarySink_put_byte(BinarySink *bs, unsigned char val)
|
|
{
|
|
bs->write(bs, &val, 1);
|
|
}
|
|
|
|
void BinarySink_put_bool(BinarySink *bs, int val)
|
|
{
|
|
unsigned char cval = val ? 1 : 0;
|
|
bs->write(bs, &cval, 1);
|
|
}
|
|
|
|
void BinarySink_put_uint16(BinarySink *bs, unsigned long val)
|
|
{
|
|
unsigned char data[2];
|
|
PUT_16BIT_MSB_FIRST(data, val);
|
|
bs->write(bs, data, sizeof(data));
|
|
}
|
|
|
|
void BinarySink_put_uint32(BinarySink *bs, unsigned long val)
|
|
{
|
|
unsigned char data[4];
|
|
PUT_32BIT_MSB_FIRST(data, val);
|
|
bs->write(bs, data, sizeof(data));
|
|
}
|
|
|
|
void BinarySink_put_uint64(BinarySink *bs, uint64 val)
|
|
{
|
|
BinarySink_put_uint32(bs, val.hi);
|
|
BinarySink_put_uint32(bs, val.lo);
|
|
}
|
|
|
|
void BinarySink_put_string(BinarySink *bs, const void *data, size_t len)
|
|
{
|
|
/* Check that the string length fits in a uint32, without doing a
|
|
* potentially implementation-defined shift of more than 31 bits */
|
|
assert((len >> 31) < 2);
|
|
|
|
BinarySink_put_uint32(bs, len);
|
|
bs->write(bs, data, len);
|
|
}
|
|
|
|
void BinarySink_put_stringz(BinarySink *bs, const char *str)
|
|
{
|
|
BinarySink_put_string(bs, str, strlen(str));
|
|
}
|
|
|
|
void BinarySink_put_stringsb(BinarySink *bs, struct strbuf *buf)
|
|
{
|
|
BinarySink_put_string(bs, buf->s, buf->len);
|
|
strbuf_free(buf);
|
|
}
|
|
|
|
void BinarySink_put_asciz(BinarySink *bs, const char *str)
|
|
{
|
|
bs->write(bs, str, strlen(str) + 1);
|
|
}
|
|
|
|
int BinarySink_put_pstring(BinarySink *bs, const char *str)
|
|
{
|
|
size_t len = strlen(str);
|
|
if (len > 255)
|
|
return FALSE; /* can't write a Pascal-style string this long */
|
|
BinarySink_put_byte(bs, len);
|
|
bs->write(bs, str, len);
|
|
return TRUE;
|
|
}
|