22#include "bufaux.h"
23#include "xmalloc.h"
24#include "getput.h"
25
26/*
27 * Stores an BIGNUM in the buffer with a 2-byte msb first bit count, followed
28 * by (bits+7)/8 bytes of binary data, msb first.
29 */
30void
31buffer_put_bignum(Buffer *buffer, BIGNUM *value)
32{
33 int bits = BN_num_bits(value);
34 int bin_size = (bits + 7) / 8;
35 char *buf = xmalloc(bin_size);
36 int oi;
37 char msg[2];
38
39 /* Get the value of in binary */
40 oi = BN_bn2bin(value, buf);
41 if (oi != bin_size)
42 fatal("buffer_put_bignum: BN_bn2bin() failed: oi %d != bin_size %d",
43 oi, bin_size);
44
45 /* Store the number of bits in the buffer in two bytes, msb first. */
46 PUT_16BIT(msg, bits);
47 buffer_append(buffer, msg, 2);
48 /* Store the binary data. */
49 buffer_append(buffer, buf, oi);
50
51 memset(buf, 0, bin_size);
52 xfree(buf);
53}
54
55/*
56 * Retrieves an BIGNUM from the buffer.
57 */
58int
59buffer_get_bignum(Buffer *buffer, BIGNUM *value)
60{
61 int bits, bytes;
62 unsigned char buf[2], *bin;
63
64 /* Get the number for bits. */
65 buffer_get(buffer, (char *) buf, 2);
66 bits = GET_16BIT(buf);
67 /* Compute the number of binary bytes that follow. */
68 bytes = (bits + 7) / 8;
69 if (buffer_len(buffer) < bytes)
70 fatal("buffer_get_bignum: input buffer too small");
71 bin = buffer_ptr(buffer);
72 BN_bin2bn(bin, bytes, value);
73 buffer_consume(buffer, bytes);
74
75 return 2 + bytes;
76}
77
78/*
79 * Returns an integer from the buffer (4 bytes, msb first).
80 */
81unsigned int
82buffer_get_int(Buffer *buffer)
83{
84 unsigned char buf[4];
85 buffer_get(buffer, (char *) buf, 4);
86 return GET_32BIT(buf);
87}
88
89/*
90 * Stores an integer in the buffer in 4 bytes, msb first.
91 */
92void
93buffer_put_int(Buffer *buffer, unsigned int value)
94{
95 char buf[4];
96 PUT_32BIT(buf, value);
97 buffer_append(buffer, buf, 4);
98}
99
100/*
101 * Returns an arbitrary binary string from the buffer. The string cannot
102 * be longer than 256k. The returned value points to memory allocated
103 * with xmalloc; it is the responsibility of the calling function to free
104 * the data. If length_ptr is non-NULL, the length of the returned data
105 * will be stored there. A null character will be automatically appended
106 * to the returned string, and is not counted in length.
107 */
108char *
109buffer_get_string(Buffer *buffer, unsigned int *length_ptr)
110{
111 unsigned int len;
112 char *value;
113 /* Get the length. */
114 len = buffer_get_int(buffer);
115 if (len > 256 * 1024)
116 fatal("Received packet with bad string length %d", len);
117 /* Allocate space for the string. Add one byte for a null character. */
118 value = xmalloc(len + 1);
119 /* Get the string. */
120 buffer_get(buffer, value, len);
121 /* Append a null character to make processing easier. */
122 value[len] = 0;
123 /* Optionally return the length of the string. */
124 if (length_ptr)
125 *length_ptr = len;
126 return value;
127}
128
129/*
130 * Stores and arbitrary binary string in the buffer.
131 */
132void
133buffer_put_string(Buffer *buffer, const void *buf, unsigned int len)
134{
135 buffer_put_int(buffer, len);
136 buffer_append(buffer, buf, len);
137}
138
139/*
140 * Returns a character from the buffer (0 - 255).
141 */
142int
143buffer_get_char(Buffer *buffer)
144{
145 char ch;
146 buffer_get(buffer, &ch, 1);
147 return (unsigned char) ch;
148}
149
150/*
151 * Stores a character in the buffer.
152 */
153void
154buffer_put_char(Buffer *buffer, int value)
155{
156 char ch = value;
157 buffer_append(buffer, &ch, 1);
158}
| 23#include "bufaux.h"
24#include "xmalloc.h"
25#include "getput.h"
26
27/*
28 * Stores an BIGNUM in the buffer with a 2-byte msb first bit count, followed
29 * by (bits+7)/8 bytes of binary data, msb first.
30 */
31void
32buffer_put_bignum(Buffer *buffer, BIGNUM *value)
33{
34 int bits = BN_num_bits(value);
35 int bin_size = (bits + 7) / 8;
36 char *buf = xmalloc(bin_size);
37 int oi;
38 char msg[2];
39
40 /* Get the value of in binary */
41 oi = BN_bn2bin(value, buf);
42 if (oi != bin_size)
43 fatal("buffer_put_bignum: BN_bn2bin() failed: oi %d != bin_size %d",
44 oi, bin_size);
45
46 /* Store the number of bits in the buffer in two bytes, msb first. */
47 PUT_16BIT(msg, bits);
48 buffer_append(buffer, msg, 2);
49 /* Store the binary data. */
50 buffer_append(buffer, buf, oi);
51
52 memset(buf, 0, bin_size);
53 xfree(buf);
54}
55
56/*
57 * Retrieves an BIGNUM from the buffer.
58 */
59int
60buffer_get_bignum(Buffer *buffer, BIGNUM *value)
61{
62 int bits, bytes;
63 unsigned char buf[2], *bin;
64
65 /* Get the number for bits. */
66 buffer_get(buffer, (char *) buf, 2);
67 bits = GET_16BIT(buf);
68 /* Compute the number of binary bytes that follow. */
69 bytes = (bits + 7) / 8;
70 if (buffer_len(buffer) < bytes)
71 fatal("buffer_get_bignum: input buffer too small");
72 bin = buffer_ptr(buffer);
73 BN_bin2bn(bin, bytes, value);
74 buffer_consume(buffer, bytes);
75
76 return 2 + bytes;
77}
78
79/*
80 * Returns an integer from the buffer (4 bytes, msb first).
81 */
82unsigned int
83buffer_get_int(Buffer *buffer)
84{
85 unsigned char buf[4];
86 buffer_get(buffer, (char *) buf, 4);
87 return GET_32BIT(buf);
88}
89
90/*
91 * Stores an integer in the buffer in 4 bytes, msb first.
92 */
93void
94buffer_put_int(Buffer *buffer, unsigned int value)
95{
96 char buf[4];
97 PUT_32BIT(buf, value);
98 buffer_append(buffer, buf, 4);
99}
100
101/*
102 * Returns an arbitrary binary string from the buffer. The string cannot
103 * be longer than 256k. The returned value points to memory allocated
104 * with xmalloc; it is the responsibility of the calling function to free
105 * the data. If length_ptr is non-NULL, the length of the returned data
106 * will be stored there. A null character will be automatically appended
107 * to the returned string, and is not counted in length.
108 */
109char *
110buffer_get_string(Buffer *buffer, unsigned int *length_ptr)
111{
112 unsigned int len;
113 char *value;
114 /* Get the length. */
115 len = buffer_get_int(buffer);
116 if (len > 256 * 1024)
117 fatal("Received packet with bad string length %d", len);
118 /* Allocate space for the string. Add one byte for a null character. */
119 value = xmalloc(len + 1);
120 /* Get the string. */
121 buffer_get(buffer, value, len);
122 /* Append a null character to make processing easier. */
123 value[len] = 0;
124 /* Optionally return the length of the string. */
125 if (length_ptr)
126 *length_ptr = len;
127 return value;
128}
129
130/*
131 * Stores and arbitrary binary string in the buffer.
132 */
133void
134buffer_put_string(Buffer *buffer, const void *buf, unsigned int len)
135{
136 buffer_put_int(buffer, len);
137 buffer_append(buffer, buf, len);
138}
139
140/*
141 * Returns a character from the buffer (0 - 255).
142 */
143int
144buffer_get_char(Buffer *buffer)
145{
146 char ch;
147 buffer_get(buffer, &ch, 1);
148 return (unsigned char) ch;
149}
150
151/*
152 * Stores a character in the buffer.
153 */
154void
155buffer_put_char(Buffer *buffer, int value)
156{
157 char ch = value;
158 buffer_append(buffer, &ch, 1);
159}
|