00001
00002
00003
00004
00005
00006
00007
00008
00009
00010 #include <ldns/config.h>
00011
00012 #include <ldns/ldns.h>
00013 #include <ldns/buffer.h>
00014
00015 ldns_buffer *
00016 ldns_buffer_new(size_t capacity)
00017 {
00018 ldns_buffer *buffer = LDNS_MALLOC(ldns_buffer);
00019
00020 if (!buffer) {
00021 return NULL;
00022 }
00023
00024 buffer->_data = (uint8_t *) LDNS_XMALLOC(uint8_t, capacity);
00025 if (!buffer->_data) {
00026 LDNS_FREE(buffer);
00027 return NULL;
00028 }
00029
00030 buffer->_position = 0;
00031 buffer->_limit = buffer->_capacity = capacity;
00032 buffer->_fixed = 0;
00033 buffer->_status = LDNS_STATUS_OK;
00034
00035 ldns_buffer_invariant(buffer);
00036
00037 return buffer;
00038 }
00039
00040 void
00041 ldns_buffer_new_frm_data(ldns_buffer *buffer, void *data, size_t size)
00042 {
00043 assert(data != NULL);
00044
00045 buffer->_position = 0;
00046 buffer->_limit = buffer->_capacity = size;
00047 buffer->_data = LDNS_XMALLOC(uint8_t, size);
00048 memcpy(buffer->_data, data, size);
00049 buffer->_fixed = 0;
00050 buffer->_status = LDNS_STATUS_OK;
00051
00052 ldns_buffer_invariant(buffer);
00053 }
00054
00055 bool
00056 ldns_buffer_set_capacity(ldns_buffer *buffer, size_t capacity)
00057 {
00058 void *data;
00059
00060 ldns_buffer_invariant(buffer);
00061 assert(buffer->_position <= capacity);
00062
00063 data = (uint8_t *) LDNS_XREALLOC(buffer->_data, uint8_t, capacity);
00064 if (!data) {
00065 buffer->_status = LDNS_STATUS_MEM_ERR;
00066 return false;
00067 } else {
00068 buffer->_data = data;
00069 buffer->_limit = buffer->_capacity = capacity;
00070 return true;
00071 }
00072 }
00073
00074 bool
00075 ldns_buffer_reserve(ldns_buffer *buffer, size_t amount)
00076 {
00077 ldns_buffer_invariant(buffer);
00078 assert(!buffer->_fixed);
00079 if (buffer->_capacity < buffer->_position + amount) {
00080 size_t new_capacity = buffer->_capacity * 3 / 2;
00081
00082 if (new_capacity < buffer->_position + amount) {
00083 new_capacity = buffer->_position + amount;
00084 }
00085 if (!ldns_buffer_set_capacity(buffer, new_capacity)) {
00086 buffer->_status = LDNS_STATUS_MEM_ERR;
00087 return false;
00088 }
00089 }
00090 buffer->_limit = buffer->_capacity;
00091 return true;
00092 }
00093
00094 int
00095 ldns_buffer_printf(ldns_buffer *buffer, const char *format, ...)
00096 {
00097 va_list args;
00098 int written = 0;
00099 size_t remaining;
00100
00101 if (ldns_buffer_status_ok(buffer)) {
00102 ldns_buffer_invariant(buffer);
00103 assert(buffer->_limit == buffer->_capacity);
00104
00105 remaining = ldns_buffer_remaining(buffer);
00106 va_start(args, format);
00107 written = vsnprintf((char *) ldns_buffer_current(buffer), remaining,
00108 format, args);
00109 va_end(args);
00110 if (written == -1) {
00111 buffer->_status = LDNS_STATUS_INTERNAL_ERR;
00112 return -1;
00113 } else if ((size_t) written >= remaining) {
00114 if (!ldns_buffer_reserve(buffer, (size_t) written + 1)) {
00115 buffer->_status = LDNS_STATUS_MEM_ERR;
00116 return -1;
00117 }
00118 va_start(args, format);
00119 written = vsnprintf((char *) ldns_buffer_current(buffer),
00120 ldns_buffer_remaining(buffer), format, args);
00121 va_end(args);
00122 if (written == -1) {
00123 buffer->_status = LDNS_STATUS_INTERNAL_ERR;
00124 return -1;
00125 }
00126 }
00127 buffer->_position += written;
00128 }
00129 return written;
00130 }
00131
00132 void
00133 ldns_buffer_free(ldns_buffer *buffer)
00134 {
00135 if (!buffer) {
00136 return;
00137 }
00138
00139 LDNS_FREE(buffer->_data);
00140
00141 LDNS_FREE(buffer);
00142 }
00143
00144 void *
00145 ldns_buffer_export(ldns_buffer *buffer)
00146 {
00147 buffer->_fixed = 1;
00148 return buffer->_data;
00149 }
00150
00151 int
00152 ldns_bgetc(ldns_buffer *buffer)
00153 {
00154 if (!ldns_buffer_available_at(buffer, buffer->_position, sizeof(uint8_t))) {
00155 ldns_buffer_set_position(buffer, ldns_buffer_limit(buffer));
00156
00157 return EOF;
00158 }
00159 return (int)ldns_buffer_read_u8(buffer);
00160 }
00161
00162 void
00163 ldns_buffer_copy(ldns_buffer* result, ldns_buffer* from)
00164 {
00165 size_t tocopy = ldns_buffer_limit(from);
00166
00167 if(tocopy > ldns_buffer_capacity(result))
00168 tocopy = ldns_buffer_capacity(result);
00169 ldns_buffer_clear(result);
00170 ldns_buffer_write(result, ldns_buffer_begin(from), tocopy);
00171 ldns_buffer_flip(result);
00172 }