bufaux.c

   1 /* $OpenBSD: bufaux.c,v 1.43 2006/07/22 20:48:22 stevesk Exp $ */
   2 /*
   3  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   4  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   5  *                    All rights reserved
   6  * Auxiliary functions for storing and retrieving various data types to/from
   7  * Buffers.
   8  *
   9  * As far as I am concerned, the code I have written for this software
  10  * can be used freely for any purpose.  Any derived versions of this
  11  * software must be clearly marked as such, and if the derived work is
  12  * incompatible with the protocol description in the RFC file, it must be
  13  * called by a name other than "ssh" or "Secure Shell".
  14  *
  15  *
  16  * SSH2 packet format added by Markus Friedl
  17  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
  18  *
  19  * Redistribution and use in source and binary forms, with or without
  20  * modification, are permitted provided that the following conditions
  21  * are met:
  22  * 1. Redistributions of source code must retain the above copyright
  23  *    notice, this list of conditions and the following disclaimer.
  24  * 2. Redistributions in binary form must reproduce the above copyright
  25  *    notice, this list of conditions and the following disclaimer in the
  26  *    documentation and/or other materials provided with the distribution.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  29  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  30  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  31  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  32  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  33  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  34  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  35  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  36  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  37  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  38  */
  39
  40 #include "includes.h"
  41
  42 #include <openssl/bn.h>
  43
  44 #include <string.h>
  45
  46 #include "bufaux.h"
  47 #include "xmalloc.h"
  48 #include "log.h"
  49 #include "misc.h"
  50
  51 /*
  52  * Returns integers from the buffer (msb first).
  53  */
  54
  55 int
  56 buffer_get_short_ret(u_short *ret, Buffer *buffer)
  57 {
  58         u_char buf[2];
  59
  60         if (buffer_get_ret(buffer, (char *) buf, 2) == -1)
  61                 return (-1);
  62         *ret = get_u16(buf);
  63         return (0);
  64 }
  65
  66 u_short
  67 buffer_get_short(Buffer *buffer)
  68 {
  69         u_short ret;
  70
  71         if (buffer_get_short_ret(&ret, buffer) == -1)
  72                 fatal("buffer_get_short: buffer error");
  73
  74         return (ret);
  75 }
  76
  77 int
  78 buffer_get_int_ret(u_int *ret, Buffer *buffer)
  79 {
  80         u_char buf[4];
  81
  82         if (buffer_get_ret(buffer, (char *) buf, 4) == -1)
  83                 return (-1);
  84         *ret = get_u32(buf);
  85         return (0);
  86 }
  87
  88 u_int
  89 buffer_get_int(Buffer *buffer)
  90 {
  91         u_int ret;
  92
  93         if (buffer_get_int_ret(&ret, buffer) == -1)
  94                 fatal("buffer_get_int: buffer error");
  95
  96         return (ret);
  97 }
  98
  99 int
 100 buffer_get_int64_ret(u_int64_t *ret, Buffer *buffer)
 101 {
 102         u_char buf[8];
 103
 104         if (buffer_get_ret(buffer, (char *) buf, 8) == -1)
 105                 return (-1);
 106         *ret = get_u64(buf);
 107         return (0);
 108 }
 109
 110 u_int64_t
 111 buffer_get_int64(Buffer *buffer)
 112 {
 113         u_int64_t ret;
 114
 115         if (buffer_get_int64_ret(&ret, buffer) == -1)
 116                 fatal("buffer_get_int: buffer error");
 117
 118         return (ret);
 119 }
 120
 121 /*
 122  * Stores integers in the buffer, msb first.
 123  */
 124 void
 125 buffer_put_short(Buffer *buffer, u_short value)
 126 {
 127         char buf[2];
 128
 129         put_u16(buf, value);
 130         buffer_append(buffer, buf, 2);
 131 }
 132
 133 void
 134 buffer_put_int(Buffer *buffer, u_int value)
 135 {
 136         char buf[4];
 137
 138         put_u32(buf, value);
 139         buffer_append(buffer, buf, 4);
 140 }
 141
 142 void
 143 buffer_put_int64(Buffer *buffer, u_int64_t value)
 144 {
 145         char buf[8];
 146
 147         put_u64(buf, value);
 148         buffer_append(buffer, buf, 8);
 149 }
 150
 151 /*
 152  * Returns an arbitrary binary string from the buffer.  The string cannot
 153  * be longer than 256k.  The returned value points to memory allocated
 154  * with xmalloc; it is the responsibility of the calling function to free
 155  * the data.  If length_ptr is non-NULL, the length of the returned data
 156  * will be stored there.  A null character will be automatically appended
 157  * to the returned string, and is not counted in length.
 158  */
 159 void *
 160 buffer_get_string_ret(Buffer *buffer, u_int *length_ptr)
 161 {
 162         u_char *value;
 163         u_int len;
 164
 165         /* Get the length. */
 166         len = buffer_get_int(buffer);
 167         if (len > 256 * 1024) {
 168                 error("buffer_get_string_ret: bad string length %u", len);
 169                 return (NULL);
 170         }
 171         /* Allocate space for the string.  Add one byte for a null character. */
 172         value = xmalloc(len + 1);
 173         /* Get the string. */
 174         if (buffer_get_ret(buffer, value, len) == -1) {
 175                 error("buffer_get_string_ret: buffer_get failed");
 176                 xfree(value);
 177                 return (NULL);
 178         }
 179         /* Append a null character to make processing easier. */
 180         value[len] = 0;
 181         /* Optionally return the length of the string. */
 182         if (length_ptr)
 183                 *length_ptr = len;
 184         return (value);
 185 }
 186
 187 void *
 188 buffer_get_string(Buffer *buffer, u_int *length_ptr)
 189 {
 190         void *ret;
 191
 192         if ((ret = buffer_get_string_ret(buffer, length_ptr)) == NULL)
 193                 fatal("buffer_get_string: buffer error");
 194         return (ret);
 195 }
 196
 197 /*
 198  * Stores and arbitrary binary string in the buffer.
 199  */
 200 void
 201 buffer_put_string(Buffer *buffer, const void *buf, u_int len)
 202 {
 203         buffer_put_int(buffer, len);
 204         buffer_append(buffer, buf, len);
 205 }
 206 void
 207 buffer_put_cstring(Buffer *buffer, const char *s)
 208 {
 209         if (s == NULL)
 210                 fatal("buffer_put_cstring: s == NULL");
 211         buffer_put_string(buffer, s, strlen(s));
 212 }
 213
 214 /*
 215  * Returns a character from the buffer (0 - 255).
 216  */
 217 int
 218 buffer_get_char_ret(char *ret, Buffer *buffer)
 219 {
 220         if (buffer_get_ret(buffer, ret, 1) == -1) {
 221                 error("buffer_get_char_ret: buffer_get_ret failed");
 222                 return (-1);
 223         }
 224         return (0);
 225 }
 226
 227 int
 228 buffer_get_char(Buffer *buffer)
 229 {
 230         char ch;
 231
 232         if (buffer_get_char_ret(&ch, buffer) == -1)
 233                 fatal("buffer_get_char: buffer error");
 234         return (u_char) ch;
 235 }
 236
 237 /*
 238  * Stores a character in the buffer.
 239  */
 240 void
 241 buffer_put_char(Buffer *buffer, int value)
 242 {
 243         char ch = value;
 244
 245         buffer_append(buffer, &ch, 1);
 246 }