/* $OpenBSD: bufaux.c,v 1.44 2006/08/03 03:34:41 deraadt Exp $ */ /* * Author: Tatu Ylonen * Copyright (c) 1995 Tatu Ylonen , Espoo, Finland * All rights reserved * Auxiliary functions for storing and retrieving various data types to/from * Buffers. * * As far as I am concerned, the code I have written for this software * can be used freely for any purpose. Any derived versions of this * software must be clearly marked as such, and if the derived work is * incompatible with the protocol description in the RFC file, it must be * called by a name other than "ssh" or "Secure Shell". * * * SSH2 packet format added by Markus Friedl * Copyright (c) 2000 Markus Friedl. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "includes.h" #include #include #include #include #include "xmalloc.h" #include "buffer.h" #include "log.h" #include "misc.h" /* * Returns integers from the buffer (msb first). */ int pamsshagentauth_buffer_get_short_ret(u_short *ret, Buffer *buffer) { u_char buf[2]; if (pamsshagentauth_buffer_get_ret(buffer, (char *) buf, 2) == -1) return (-1); *ret = pamsshagentauth_get_u16(buf); return (0); } u_short pamsshagentauth_buffer_get_short(Buffer *buffer) { u_short ret; if (pamsshagentauth_buffer_get_short_ret(&ret, buffer) == -1) pamsshagentauth_fatal("buffer_get_short: buffer error"); return (ret); } int pamsshagentauth_buffer_get_int_ret(u_int *ret, Buffer *buffer) { u_char buf[4]; if (pamsshagentauth_buffer_get_ret(buffer, (char *) buf, 4) == -1) return (-1); *ret = pamsshagentauth_get_u32(buf); return (0); } u_int pamsshagentauth_buffer_get_int(Buffer *buffer) { u_int ret; if (pamsshagentauth_buffer_get_int_ret(&ret, buffer) == -1) pamsshagentauth_fatal("buffer_get_int: buffer error"); return (ret); } int pamsshagentauth_buffer_get_int64_ret(u_int64_t *ret, Buffer *buffer) { u_char buf[8]; if (pamsshagentauth_buffer_get_ret(buffer, (char *) buf, 8) == -1) return (-1); *ret = pamsshagentauth_get_u64(buf); return (0); } u_int64_t pamsshagentauth_buffer_get_int64(Buffer *buffer) { u_int64_t ret; if (pamsshagentauth_buffer_get_int64_ret(&ret, buffer) == -1) pamsshagentauth_fatal("buffer_get_int: buffer error"); return (ret); } /* * Stores integers in the buffer, msb first. */ void pamsshagentauth_buffer_put_short(Buffer *buffer, u_short value) { char buf[2]; pamsshagentauth_put_u16(buf, value); pamsshagentauth_buffer_append(buffer, buf, 2); } void pamsshagentauth_buffer_put_int(Buffer *buffer, u_int value) { char buf[4]; pamsshagentauth_put_u32(buf, value); pamsshagentauth_buffer_append(buffer, buf, 4); } void pamsshagentauth_buffer_put_int64(Buffer *buffer, u_int64_t value) { char buf[8]; pamsshagentauth_put_u64(buf, value); pamsshagentauth_buffer_append(buffer, buf, 8); } /* * Returns an arbitrary binary string from the buffer. The string cannot * be longer than 256k. The returned value points to memory allocated * with xmalloc; it is the responsibility of the calling function to free * the data. If length_ptr is non-NULL, the length of the returned data * will be stored there. A null character will be automatically appended * to the returned string, and is not counted in length. */ void * pamsshagentauth_buffer_get_string_ret(Buffer *buffer, u_int *length_ptr) { u_char *value; u_int len; /* Get the length. */ len = pamsshagentauth_buffer_get_int(buffer); if (len > 256 * 1024) { pamsshagentauth_logerror("buffer_get_string_ret: bad string length %u", len); return (NULL); } /* Allocate space for the string. Add one byte for a null character. */ value = pamsshagentauth_xmalloc(len + 1); /* Get the string. */ if (pamsshagentauth_buffer_get_ret(buffer, value, len) == -1) { pamsshagentauth_logerror("buffer_get_string_ret: buffer_get failed"); pamsshagentauth_xfree(value); return (NULL); } /* Append a null character to make processing easier. */ value[len] = 0; /* Optionally return the length of the string. */ if (length_ptr) *length_ptr = len; return (value); } void * pamsshagentauth_buffer_get_string(Buffer *buffer, u_int *length_ptr) { void *ret; if ((ret = pamsshagentauth_buffer_get_string_ret(buffer, length_ptr)) == NULL) pamsshagentauth_fatal("buffer_get_string: buffer error"); return (ret); } /* * Stores and arbitrary binary string in the buffer. */ void pamsshagentauth_buffer_put_string(Buffer *buffer, const void *buf, u_int len) { pamsshagentauth_buffer_put_int(buffer, len); pamsshagentauth_buffer_append(buffer, buf, len); } void pamsshagentauth_buffer_put_cstring(Buffer *buffer, const char *s) { if (s == NULL) pamsshagentauth_fatal("buffer_put_cstring: s == NULL"); pamsshagentauth_buffer_put_string(buffer, s, strlen(s)); } /* * Returns a character from the buffer (0 - 255). */ int pamsshagentauth_buffer_get_char_ret(char *ret, Buffer *buffer) { if (pamsshagentauth_buffer_get_ret(buffer, ret, 1) == -1) { pamsshagentauth_logerror("buffer_get_char_ret: buffer_get_ret failed"); return (-1); } return (0); } int pamsshagentauth_buffer_get_char(Buffer *buffer) { char ch; if (pamsshagentauth_buffer_get_char_ret(&ch, buffer) == -1) pamsshagentauth_fatal("buffer_get_char: buffer error"); return (u_char) ch; } /* * Stores a character in the buffer. */ void pamsshagentauth_buffer_put_char(Buffer *buffer, int value) { char ch = value; pamsshagentauth_buffer_append(buffer, &ch, 1); }