# endif
typedef struct {
- /* Pointer to the start of the buffer data */
- unsigned char *start;
-
- /* Pointer to the first byte after the end of the buffer data */
- unsigned char *end;
-
/* Pointer to where we are currently reading from */
unsigned char *curr;
+ /* Number of bytes remaining */
+ size_t remaining;
} PACKET;
+/* Internal unchecked shorthand; don't use outside this file. */
+static inline void packet_forward(PACKET *pkt, size_t len)
+{
+ pkt->curr += len;
+ pkt->remaining -= len;
+}
+
+/*
+ * Returns the number of bytes remaining to be read in the PACKET
+ */
+__owur static inline size_t PACKET_remaining(const PACKET *pkt)
+{
+ return pkt->remaining;
+}
+
/*
- * Returns 1 if there are exactly |len| bytes left to be read from |pkt|
- * and 0 otherwise
+ * Returns a pointer to the PACKET's current position.
+ * For use in non-PACKETized APIs.
+ * TODO(openssl-team): this should return 'const unsigned char*' but can't
+ * currently because legacy code passes 'unsigned char*'s around.
*/
-__owur static inline size_t PACKET_remaining(PACKET *pkt)
+static inline unsigned char *PACKET_data(const PACKET *pkt)
{
- return (size_t)(pkt->end - pkt->curr);
+ return pkt->curr;
}
/*
*/
static inline int PACKET_buf_init(PACKET *pkt, unsigned char *buf, size_t len)
{
- pkt->start = pkt->curr = buf;
- pkt->end = pkt->start + len;
-
- /* Sanity checks */
- if (pkt->start > pkt->end
- || pkt->curr < pkt->start
- || pkt->curr > pkt->end
- || len != (size_t)(pkt->end - pkt->start)) {
+ /* Sanity check for negative values. */
+ if (buf + len < buf)
return 0;
- }
+ pkt->curr = buf;
+ pkt->remaining = len;
return 1;
}
+/* Initialize a PACKET to hold zero bytes. */
+static inline void PACKET_null_init(PACKET *pkt)
+{
+ pkt->curr = NULL;
+ pkt->remaining = 0;
+}
+
/*
* Peek ahead and initialize |subpkt| with the next |len| bytes read from |pkt|.
* Data is not copied: the |subpkt| packet will share its underlying buffer with
* the original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|.
*/
-__owur static inline int PACKET_peek_sub_packet(PACKET *pkt, PACKET *subpkt,
- size_t len)
+__owur static inline int PACKET_peek_sub_packet(const PACKET *pkt,
+ PACKET *subpkt, size_t len)
{
if (PACKET_remaining(pkt) < len)
return 0;
if (!PACKET_peek_sub_packet(pkt, subpkt, len))
return 0;
- pkt->curr += len;
+ packet_forward(pkt, len);
return 1;
}
/* Peek ahead at 2 bytes in network order from |pkt| and store the value in
* |*data|
*/
-__owur static inline int PACKET_peek_net_2(PACKET *pkt, unsigned int *data)
+__owur static inline int PACKET_peek_net_2(const PACKET *pkt,
+ unsigned int *data)
{
if (PACKET_remaining(pkt) < 2)
return 0;
if (!PACKET_peek_net_2(pkt, data))
return 0;
- pkt->curr += 2;
+ packet_forward(pkt, 2);
return 1;
}
/* Peek ahead at 3 bytes in network order from |pkt| and store the value in
* |*data|
*/
-__owur static inline int PACKET_peek_net_3(PACKET *pkt, unsigned long *data)
+__owur static inline int PACKET_peek_net_3(const PACKET *pkt,
+ unsigned long *data)
{
if (PACKET_remaining(pkt) < 3)
return 0;
*data = ((unsigned long)(*pkt->curr)) << 16;
- *data |= ((unsigned long)(*pkt->curr + 1)) << 8;
- *data |= *pkt->curr + 2;
+ *data |= ((unsigned long)(*(pkt->curr + 1))) << 8;
+ *data |= *(pkt->curr + 2);
return 1;
}
if (!PACKET_peek_net_3(pkt, data))
return 0;
- pkt->curr += 3;
+ packet_forward(pkt, 3);
return 1;
}
/* Peek ahead at 4 bytes in network order from |pkt| and store the value in
* |*data|
*/
-__owur static inline int PACKET_peek_net_4(PACKET *pkt, unsigned long *data)
+__owur static inline int PACKET_peek_net_4(const PACKET *pkt,
+ unsigned long *data)
{
if (PACKET_remaining(pkt) < 4)
return 0;
*data = ((unsigned long)(*pkt->curr)) << 24;
- *data |= ((unsigned long)(*pkt->curr + 1)) << 16;
- *data |= ((unsigned long)(*pkt->curr + 2)) << 8;
- *data |= *pkt->curr+3;
+ *data |= ((unsigned long)(*(pkt->curr + 1))) << 16;
+ *data |= ((unsigned long)(*(pkt->curr + 2))) << 8;
+ *data |= *(pkt->curr+3);
return 1;
}
if (!PACKET_peek_net_4(pkt, data))
return 0;
- pkt->curr += 4;
+ packet_forward(pkt, 4);
return 1;
}
/* Peek ahead at 1 byte from |pkt| and store the value in |*data| */
-__owur static inline int PACKET_peek_1(PACKET *pkt, unsigned int *data)
+__owur static inline int PACKET_peek_1(const PACKET *pkt, unsigned int *data)
{
if (!PACKET_remaining(pkt))
return 0;
if (!PACKET_peek_1(pkt, data))
return 0;
- pkt->curr++;
+ packet_forward(pkt, 1);
return 1;
}
* Peek ahead at 4 bytes in reverse network order from |pkt| and store the value
* in |*data|
*/
-__owur static inline int PACKET_peek_4(PACKET *pkt, unsigned long *data)
+__owur static inline int PACKET_peek_4(const PACKET *pkt, unsigned long *data)
{
if (PACKET_remaining(pkt) < 4)
return 0;
*data = *pkt->curr;
- *data |= ((unsigned long)(*pkt->curr + 1)) << 8;
- *data |= ((unsigned long)(*pkt->curr + 2)) << 16;
- *data |= ((unsigned long)(*pkt->curr + 3)) << 24;
+ *data |= ((unsigned long)(*(pkt->curr + 1))) << 8;
+ *data |= ((unsigned long)(*(pkt->curr + 2))) << 16;
+ *data |= ((unsigned long)(*(pkt->curr + 3))) << 24;
return 1;
}
if (!PACKET_peek_4(pkt, data))
return 0;
- pkt->curr += 4;
+ packet_forward(pkt, 4);
return 1;
}
* caller should not free this data directly (it will be freed when the
* underlying buffer gets freed
*/
-__owur static inline int PACKET_peek_bytes(PACKET *pkt, unsigned char **data,
- size_t len)
+__owur static inline int PACKET_peek_bytes(const PACKET *pkt, unsigned char **data,
+ size_t len)
{
if (PACKET_remaining(pkt) < len)
return 0;
if (!PACKET_peek_bytes(pkt, data, len))
return 0;
- pkt->curr += len;
+ packet_forward(pkt, len);
return 1;
}
/* Peek ahead at |len| bytes from |pkt| and copy them to |data| */
-__owur static inline int PACKET_peek_copy_bytes(PACKET *pkt,
+__owur static inline int PACKET_peek_copy_bytes(const PACKET *pkt,
unsigned char *data, size_t len)
{
if (PACKET_remaining(pkt) < len)
return 1;
}
-/* Read |len| bytes from |pkt| and copy them to |data| */
+/*
+ * Read |len| bytes from |pkt| and copy them to |data|.
+ * The caller is responsible for ensuring that |data| can hold |len| bytes.
+ */
__owur static inline int PACKET_copy_bytes(PACKET *pkt, unsigned char *data,
- size_t len)
+ size_t len)
{
if (!PACKET_peek_copy_bytes(pkt, data, len))
return 0;
- pkt->curr += len;
+ packet_forward(pkt, len);
return 1;
}
-/* Move the current reading position back |len| bytes */
-__owur static inline int PACKET_back(PACKET *pkt, size_t len)
-{
- if (len > (size_t)(pkt->curr - pkt->start))
+/*
+ * Copy packet data to |dest|, and set |len| to the number of copied bytes.
+ * If the packet has more than |dest_len| bytes, nothing is copied.
+ * Returns 1 if the packet data fits in |dest_len| bytes, 0 otherwise.
+ * Does not forward PACKET position (because it is typically the last thing
+ * done with a given PACKET).
+ */
+__owur static inline int PACKET_copy_all(const PACKET *pkt, unsigned char *dest,
+ size_t dest_len, size_t *len) {
+ if (PACKET_remaining(pkt) > dest_len) {
+ *len = 0;
return 0;
-
- pkt->curr -= len;
-
+ }
+ *len = pkt->remaining;
+ memcpy(dest, pkt->curr, pkt->remaining);
return 1;
}
-/* Move the current reading position forward |len| bytes */
-__owur static inline int PACKET_forward(PACKET *pkt, size_t len)
+/*
+ * Copy |pkt| bytes to a newly allocated buffer and store a pointer to the
+ * result in |*data|, and the length in |len|.
+ * If |*data| is not NULL, the old data is OPENSSL_free'd.
+ * If the packet is empty, or malloc fails, |*data| will be set to NULL.
+ * Returns 1 if the malloc succeeds and 0 otherwise.
+ * Does not forward PACKET position (because it is typically the last thing
+ * done with a given PACKET).
+ */
+__owur static inline int PACKET_memdup(const PACKET *pkt, unsigned char **data,
+ size_t *len)
{
- if (PACKET_remaining(pkt) < len)
- return 0;
+ size_t length;
- pkt->curr += len;
+ OPENSSL_free(*data);
+ *data = NULL;
+ *len = 0;
+
+ length = PACKET_remaining(pkt);
+
+ if (length == 0)
+ return 1;
+
+ *data = BUF_memdup(pkt->curr, length);
+
+ if (*data == NULL)
+ return 0;
+ *len = length;
return 1;
}
-/* Store a bookmark for the current reading position in |*bm| */
-__owur static inline int PACKET_get_bookmark(PACKET *pkt, size_t *bm)
+/*
+ * Read a C string from |pkt| and copy to a newly allocated, NUL-terminated
+ * buffer. Store a pointer to the result in |*data|.
+ * If |*data| is not NULL, the old data is OPENSSL_free'd.
+ * If the data in |pkt| does not contain a NUL-byte, the entire data is
+ * copied and NUL-terminated.
+ * Returns 1 if the malloc succeeds and 0 otherwise.
+ * Does not forward PACKET position (because it is typically the last thing done
+ * with a given PACKET).
+ */
+__owur static inline int PACKET_strndup(const PACKET *pkt, char **data)
{
- *bm = pkt->curr - pkt->start;
+ OPENSSL_free(*data);
- return 1;
+ /* This will succeed on an empty packet, unless pkt->curr == NULL. */
+ *data = BUF_strndup((const char*)pkt->curr, PACKET_remaining(pkt));
+ return (*data != NULL);
}
-/* Set the current reading position to the bookmark |bm| */
-__owur static inline int PACKET_goto_bookmark(PACKET *pkt, size_t bm)
+/* Move the current reading position forward |len| bytes */
+__owur static inline int PACKET_forward(PACKET *pkt, size_t len)
{
- if (bm > (size_t)(pkt->end - pkt->start))
+ if (PACKET_remaining(pkt) < len)
return 0;
- pkt->curr = pkt->start + bm;
+ packet_forward(pkt, len);
return 1;
}
/*
- * Stores the total length of the packet we have in the underlying buffer in
- * |*len|
+ * Reads a variable-length vector prefixed with a one-byte length, and stores
+ * the contents in |subpkt|. |pkt| can equal |subpkt|.
+ * Data is not copied: the |subpkt| packet will share its underlying buffer with
+ * the original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|.
+ * Upon failure, the original |pkt| and |subpkt| are not modified.
*/
-__owur static inline int PACKET_length(PACKET *pkt, size_t *len)
+__owur static inline int PACKET_get_length_prefixed_1(PACKET *pkt, PACKET *subpkt)
{
- *len = pkt->end - pkt->start;
+ unsigned int length;
+ unsigned char *data;
+ PACKET tmp = *pkt;
+ if (!PACKET_get_1(&tmp, &length) ||
+ !PACKET_get_bytes(&tmp, &data, (size_t)length)) {
+ return 0;
+ }
+
+ *pkt = tmp;
+ subpkt->curr = data;
+ subpkt->remaining = length;
+
+ return 1;
+}
- return 1;
+/*
+ * Reads a variable-length vector prefixed with a two-byte length, and stores
+ * the contents in |subpkt|. |pkt| can equal |subpkt|.
+ * Data is not copied: the |subpkt| packet will share its underlying buffer with
+ * the original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|.
+ * Upon failure, the original |pkt| and |subpkt| are not modified.
+ */
+__owur static inline int PACKET_get_length_prefixed_2(PACKET *pkt, PACKET *subpkt)
+{
+ unsigned int length;
+ unsigned char *data;
+ PACKET tmp = *pkt;
+ if (!PACKET_get_net_2(&tmp, &length) ||
+ !PACKET_get_bytes(&tmp, &data, (size_t)length)) {
+ return 0;
+ }
+
+ *pkt = tmp;
+ subpkt->curr = data;
+ subpkt->remaining = length;
+
+ return 1;
}
+/*
+ * Reads a variable-length vector prefixed with a three-byte length, and stores
+ * the contents in |subpkt|. |pkt| can equal |subpkt|.
+ * Data is not copied: the |subpkt| packet will share its underlying buffer with
+ * the original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|.
+ * Upon failure, the original |pkt| and |subpkt| are not modified.
+ */
+__owur static inline int PACKET_get_length_prefixed_3(PACKET *pkt, PACKET *subpkt)
+{
+ unsigned long length;
+ unsigned char *data;
+ PACKET tmp = *pkt;
+ if (!PACKET_get_net_3(&tmp, &length) ||
+ !PACKET_get_bytes(&tmp, &data, (size_t)length)) {
+ return 0;
+ }
+
+ *pkt = tmp;
+ subpkt->curr = data;
+ subpkt->remaining = length;
+
+ return 1;
+}
# ifdef __cplusplus
}
# endif
#endif /* HEADER_PACKET_LOCL_H */
-
projects / openssl.git / blobdiff