buffer_network.c

00001 /*
00002 MiniTLS - A super trimmed down TLS/SSL Library for embedded devices
00003 Author: Donatien Garnier
00004 Copyright (C) 2013-2014 AppNearMe Ltd
00005 
00006 This program is free software; you can redistribute it and/or
00007 modify it under the terms of the GNU General Public License
00008 as published by the Free Software Foundation; either version 2
00009 of the License, or (at your option) any later version.
00010 
00011 This program is distributed in the hope that it will be useful,
00012 but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 GNU General Public License for more details.
00015 
00016 You should have received a copy of the GNU General Public License
00017 along with this program; if not, write to the Free Software
00018 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
00019 *//**
00020  * \file buffer_network.c
00021  * \copyright Copyright (c) AppNearMe Ltd 2013
00022  * \author Donatien Garnier
00023  */
00024 
00025 #include "core/fwk.h"
00026 
00027 #include "buffer_network.h"
00028 
00029 #define VOID
00030 #define ENSURE_READ_LENGTH(b, n, r) do{ if(b->end - b->start < n) { return r; } }while(0);
00031 #define ENSURE_WRITE_LENGTH(b, n) do{ if(b->bufdata + b->size - b->end < n) { return; } }while(0);
00032 
00033 uint8_t buffer_nu8_read(buffer_t* buffer)
00034 {
00035   uint8_t hu8;
00036   ENSURE_READ_LENGTH(buffer, 1, 0);
00037   hu8 = buffer->start[0];
00038   buffer->start++;
00039   return hu8;
00040 }
00041 
00042 uint16_t buffer_nu16_read(buffer_t* buffer)
00043 {
00044   uint16_t hu16;
00045   ENSURE_READ_LENGTH(buffer, 2, 0);
00046   hu16 = (buffer->start[0] << 8) | buffer->start[1];
00047   buffer->start+=2;
00048   return hu16;
00049 }
00050 
00051 uint32_t buffer_nu24_read(buffer_t* buffer)
00052 {
00053   uint32_t hu24;
00054   ENSURE_READ_LENGTH(buffer, 3, 0);
00055   hu24 = (buffer->start[0] << 16) | (buffer->start[1] << 8) | buffer->start[2];
00056   buffer->start+=3;
00057   return hu24;
00058 }
00059 
00060 uint32_t buffer_nu32_read(buffer_t* buffer)
00061 {
00062   uint32_t hu32;
00063   ENSURE_READ_LENGTH(buffer, 4, 0);
00064   hu32 = (buffer->start[0] << 24) | (buffer->start[1] << 16) | (buffer->start[2] << 8) | buffer->start[3];
00065   buffer->start+=4;
00066   return hu32;
00067 }
00068 
00069 uint64_t buffer_nu64_read(buffer_t* buffer)
00070 {
00071   uint64_t hu64;
00072   ENSURE_READ_LENGTH(buffer, 8, 0);
00073   hu64 = ((uint64_t)buffer->start[0] << 56) | ((uint64_t)buffer->start[1] << 48) | ((uint64_t)buffer->start[2] << 40) | ((uint64_t)buffer->start[3] << 32)
00074       | (buffer->start[4] << 24) | (buffer->start[5] << 16) | (buffer->start[6] << 8) | buffer->start[7];
00075   buffer->start+=8;
00076   return hu64;
00077 }
00078 
00079 void buffer_nbytes_read(buffer_t* buffer, uint8_t* data, size_t size)
00080 {
00081   ENSURE_READ_LENGTH(buffer, size, VOID);
00082   memcpy(data, buffer->start, size);
00083   buffer->start+=size;
00084 }
00085 
00086 void buffer_n_discard(buffer_t* buffer, size_t size)
00087 {
00088   ENSURE_READ_LENGTH(buffer, size, VOID);
00089   buffer->start+=size;
00090 }
00091 
00092 uint8_t* buffer_current_read_position(buffer_t* buffer)
00093 {
00094   return buffer->start;
00095 }
00096 
00097 size_t buffer_get_read_offset(buffer_t* buffer)
00098 {
00099   return buffer->start - buffer->bufdata;
00100 }
00101 
00102 void buffer_set_read_offset(buffer_t* buffer, size_t off)
00103 {
00104   if( buffer->bufdata + off > buffer->end )
00105   {
00106     return;
00107   }
00108   buffer->start = buffer->bufdata + off;
00109 }
00110 
00111 void buffer_nu8_write(buffer_t* buffer, uint8_t hu8)
00112 {
00113   ENSURE_WRITE_LENGTH(buffer, 1);
00114   buffer->end[0] = hu8;
00115   buffer->end++;
00116 }
00117 
00118 void buffer_nu16_write(buffer_t* buffer, uint16_t hu16)
00119 {
00120   ENSURE_WRITE_LENGTH(buffer, 2);
00121   buffer->end[0] = (hu16 >> 8) & 0xFF;
00122   buffer->end[1] = hu16 & 0xFF;
00123   buffer->end+=2;
00124 }
00125 
00126 void buffer_nu24_write(buffer_t* buffer, uint32_t hu24)
00127 {
00128   ENSURE_WRITE_LENGTH(buffer, 3);
00129   buffer->end[0] = (hu24 >> 16) & 0xFF;
00130   buffer->end[1] = (hu24 >> 8) & 0xFF;
00131   buffer->end[2] = hu24 & 0xFF;
00132   buffer->end+=3;
00133 }
00134 
00135 void buffer_nu32_write(buffer_t* buffer, uint32_t hu32)
00136 {
00137   ENSURE_WRITE_LENGTH(buffer, 4);
00138   buffer->end[0] = (hu32 >> 24) & 0xFF;
00139   buffer->end[1] = (hu32 >> 16) & 0xFF;
00140   buffer->end[2] = (hu32 >> 8) & 0xFF;
00141   buffer->end[3] = hu32 & 0xFF;
00142   buffer->end+=4;
00143 }
00144 
00145 void buffer_nu64_write(buffer_t* buffer, uint64_t hu64)
00146 {
00147   ENSURE_WRITE_LENGTH(buffer, 8);
00148   buffer->end[0] = (hu64 >> 56) & 0xFF;
00149   buffer->end[1] = (hu64 >> 48) & 0xFF;
00150   buffer->end[2] = (hu64 >> 40) & 0xFF;
00151   buffer->end[3] = (hu64 >> 32) & 0xFF;
00152   buffer->end[4] = (hu64 >> 24) & 0xFF;
00153   buffer->end[5] = (hu64 >> 16) & 0xFF;
00154   buffer->end[6] = (hu64 >> 8) & 0xFF;
00155   buffer->end[7] = hu64 & 0xFF;
00156   buffer->end+=8;
00157 }
00158 
00159 void buffer_nbytes_write(buffer_t* buffer, const uint8_t* data, size_t size)
00160 {
00161   ENSURE_WRITE_LENGTH(buffer, size);
00162   memcpy(buffer->end, data, size);
00163   buffer->end+=size;
00164 }
00165 
00166 void buffer_n_skip(buffer_t* buffer, size_t size)
00167 {
00168   ENSURE_WRITE_LENGTH(buffer, size);
00169   buffer->end+=size;
00170 }
00171 
00172 uint8_t* buffer_current_write_position(buffer_t* buffer)
00173 {
00174   return buffer->end;
00175 }