Skip to content
Permalink
08b21ea20d
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Go to file
 
 
Cannot retrieve contributors at this time
1078 lines (864 sloc) 29.8 KB
/* Copyright (c) 2002-2023 Sam Trenholme
*
* TERMS
*
* 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 'as is' with no guarantees of correctness or
* fitness for purpose.
*/
#include <stdio.h>
#include "../MaraDns.h"
#include "../server/timestamp.h"
#include "Compress_rrs.h"
#include "Compress_rrdescs.h" /* The description of RRs to decompress */
#include "functions_dns.h"
/* Some definitions */
#define MAX_DLABEL_LEN 256
#define MAX_RR_SECTIONS 16
/* The hash that stores RRs */
rrdesc **rr_formats;
/* Whether to show verbose messages */
int dlog_level = -1; /* -1 means uninitialized */
/* decomp_message: Show, if needed, a message to the user.
Input: null-terminated string with the message, minimum log level
before which we will show the message
Output: JS_SUCCESS
*/
int decomp_message(char *message, int min_log_level) {
if(dlog_level >= min_log_level) {
show_timestamp();
printf("%s\n",message);
}
return JS_SUCCESS;
}
/* decomp_get_label: Uncompress a dlabel from a compressed string,
generating a js_string object which will store the decompressed
dlabel.
Input:
compressed: The compressed string
compressed_offset: The offset from the beginning of the string
where the compressed dlabel begins
Output:
The output of this function is a newly created js_string object
which contains the decompressed dlabel. If there was any problem
decompressing the dlabel in question, this routine will return a 0.
*/
js_string *decomp_get_label(js_string *compressed,
unsigned int compressed_offset) {
js_string *ret; /* The string we return */
int counter, cplace, cplace_save, dplace, limit;
decomp_message("Performing sanity checks on compressed string...",5);
/* Sanity checks */
if(compressed == 0)
return 0;
if(compressed->unit_size != 1)
return 0;
if(compressed->unit_count > compressed->max_count)
return 0;
if(compressed_offset > compressed->unit_count)
return 0;
decomp_message("Compressed string is sane. Initializing variables...",5);
/* Initialize the variables */
cplace = compressed_offset;
cplace_save = cplace;
dplace = 0;
counter = 0;
limit = 0;
if((ret = js_create(MAX_DLABEL_LEN + 3,1)) == 0)
return 0;
decomp_message("Variables initalized.",5);
/* Decompress and copy */
do {
if(cplace >= compressed->unit_count) {
js_destroy(ret);
return 0;
}
limit++;
counter = *(compressed->string + cplace);
/* We do not allow invalid length values */
if(counter > 63 && counter < 0xC0) {
decomp_message("Invalid length value in compressed string",4);
js_destroy(ret);
return 0;
}
else if(counter >= 0xC0) { /* Compression pointer */
/* Make sure we have two bytes for the compression pointer */
if(cplace + 1 >= compressed->unit_count) {
decomp_message("Compression pointer isn't fitting",4);
js_destroy(ret);
return 0;
}
/* Get the compression pointer */
cplace_save = cplace;
cplace = ((counter & 0x3F) << 8);
cplace |= *(compressed->string + cplace_save + 1);
/* All compression labels must go backwards */
if(cplace >= cplace_save) {
decomp_message("Compressed pointer goes forward",4);
js_destroy(ret);
return 0;
}
/* All compression lables must start past the header */
if(cplace < 12) {
decomp_message("Compressed pointer points to header",4);
js_destroy(ret);
return 0;
}
}
/* Normal length dlabel */
else if(counter > 0 && counter <= 63) {
counter++;
if(dplace + counter >= ret->max_count) {
decomp_message("Pointing past end of ret string",4);
js_destroy(ret);
return 0;
}
if(cplace + counter >= compressed->unit_count) {
decomp_message("Pointing past end of compressed string",4);
js_destroy(ret);
return 0;
}
while(counter > 0) {
*(ret->string + dplace) = *(compressed->string + cplace);
ret->unit_count++;
dplace++;
cplace++;
counter--;
}
counter = 100; /* So we don't break out of loop */
}
else if(counter == 0) {
if(dplace + counter >= ret->max_count) {
decomp_message("Pointing past end of the compressed string",4);
js_destroy(ret);
return 0;
}
*(ret->string + dplace) = 0;
ret->unit_count++;
}
else { /* Should never happen */
decomp_message("This, folks, should never happen",4);
js_destroy(ret);
return 0;
}
} while(counter > 0 && limit < 256);
if(limit >= 256) {
decomp_message("Limit exceeded when decompressing dlabel",4);
js_destroy(ret);
return 0;
}
/* Force core dump */
/**(ret->string + 1000000) = 0;*/
return ret;
}
/* decomp_append_dlabel: Get a dlabel from the compressed string,
appending the uncompressed dlabel to the uncompressed string.
Input:
compressed: The compressed string
uncompressed: The partially decompressed string
compressed_offset: Where in the string to look (0 is the top of the
string, 1 is the second byte of the string, etc.)
Output:
The length of the compressed dlabel; JS_ERROR if there was an
error decompressing
*/
int decomp_append_dlabel(js_string *compressed, js_string *uncompressed,
unsigned int compressed_offset) {
js_string *dlabel;
int length = 0;
/* Sanity checks */
if(js_has_sanity(compressed) != JS_SUCCESS) {
return JS_ERROR;
}
if(js_has_sanity(uncompressed) != JS_SUCCESS) {
return JS_ERROR;
}
if(compressed->unit_size != 1) {
return JS_ERROR;
}
if(uncompressed->unit_size != 1) {
return JS_ERROR;
}
if(compressed_offset >= compressed->unit_count) {
return JS_ERROR;
}
/* Get and process the actual compressed dname to append */
dlabel = decomp_get_label(compressed, compressed_offset);
if(dlabel == 0) {
return JS_ERROR;
}
length = dlabel_length(compressed,compressed_offset);
if(length == JS_ERROR) {
js_destroy(dlabel);
return JS_ERROR;
}
/* Append the label in question */
if(js_append(dlabel,uncompressed) == JS_ERROR) {
js_destroy(dlabel);
return JS_ERROR;
}
/* Success! */
js_destroy(dlabel);
return length;
}
/* decomp_append_bytes:
Given the user-specified substring of one js_string object, append
that data to another js_string (this is used a lot with the
decompression code)
Input
compressed: The string we will be appending from
uncompressed: The string we will be appending to
compressed_offset: The offset to start the appending from
length: The number of bytes to append
Output
JS_ERROR on error
JS_SUCCESS on success
Note
This really should eventually become a JsStr primitive
*/
int decomp_append_bytes(js_string *compressed, js_string *uncompressed,
unsigned int compressed_offset, int length) {
js_string *temp;
if((temp = js_create(length + 2,1)) == 0) {
return JS_ERROR;
}
if(compressed->unit_count < compressed_offset + length) {
js_destroy(temp);
return JS_ERROR;
}
if(js_substr(compressed,temp,compressed_offset,length) != JS_SUCCESS) {
js_destroy(temp);
return JS_ERROR;
}
if(js_append(temp,uncompressed) == JS_ERROR) {
js_destroy(temp);
return JS_ERROR;
}
js_destroy(temp);
return JS_SUCCESS;
}
/* decomp_get_type_etc:
Get the resource record type (and some other data: The class and TTL, which
do not matter as far as decompressing a string are concerned) from the
compressed string, and copy the data over to the uncompressed string.
Input
compressed: The compressed string
uncompressed: The partially decompressed string
compressed_offset: Where in the string to look (0 is the top of the
string, 1 is the second byte of the string, etc.)
Output
JS_ERROR on error; RR type (0-65536) on success
Increase offset by eight bytes after running this.
*/
int decomp_get_type_etc(js_string *compressed, js_string
*uncompressed, unsigned int compressed_offset) {
int type;
type = js_readuint16(compressed,compressed_offset);
if(decomp_append_bytes(compressed,uncompressed,compressed_offset,8) !=
JS_SUCCESS) {
return JS_ERROR;
}
return type;
}
/* decomp_get_rdlength
Get the resource record rdlength from the compressed string.
Note that this is how long the rddata is *compressed*, the
length can very well change when it is uncompreseed.
Input
compressed: The compressed string
compressed_offset: Where in the string to look (0 is the top of
the string, 1 is the second byte of the string,
etc.)
Output
JS_ERROR on error, RDLENGTH (0-65536) on success
*/
int decomp_get_rdlength(js_string *compressed,
unsigned int compressed_offset) {
int rdlength;
rdlength = js_readuint16(compressed,compressed_offset);
return rdlength;
}
/* decomp_get_header
Get the 12 byte header for a DNS packet; making sure that qdcount
(bytes 5 and 6 in big endian format) is 0 or one; and that there are
no answers if qdcount is 0.
Input
compressed: The compressed string
uncompressed: The empty uncompressed string (returns error if string
is not empty)
Output
The total number of answers; -2 if there are no questions and no
answers; JS_ERROR (-1) on error; -3 if there are no questions and
one answer (yes, some DNS servers do this with zone files)
*/
int decomp_get_header(js_string *compressed, js_string *uncompressed) {
int qdcount, ancount, nscount, arcount, total;
/* Sanity checks */
if(js_has_sanity(compressed) == JS_ERROR) {
return JS_ERROR;
}
if(js_has_sanity(uncompressed) == JS_ERROR) {
return JS_ERROR;
}
if(compressed->unit_count < 12) {
return JS_ERROR;
}
if(uncompressed->unit_count != 0) {
return JS_ERROR;
}
/* Get the number of questions */
qdcount = js_readuint16(compressed,4);
if(qdcount < 0 || qdcount > 1)
return JS_ERROR;
/* Get the number of answers */
ancount = js_readuint16(compressed,6);
if(ancount < 0 || ancount > 65535)
return JS_ERROR;
nscount = js_readuint16(compressed,8);
if(nscount < 0 || nscount > 65535)
return JS_ERROR;
arcount = js_readuint16(compressed,10);
if(arcount < 0 || arcount > 65535)
return JS_ERROR;
total = ancount + nscount + arcount;
/* Copy the data over */
if(decomp_append_bytes(compressed,uncompressed,0,12) != JS_SUCCESS)
return JS_ERROR;
/* Yes, some zone servers do this */
if(qdcount == 0 && total >= 1)
return -2 - total;
/* And return the number of answers */
if(qdcount == 0)
return -2;
return total;
}
/* decomp_get_question
Get the question from the DNS packet; it is assumed that the question
starts on the 13th byte.
Input
compressed: The compressed string
uncompressed: The compressed string with only 12 bytes in it (returns
error if string does not have 12 bytes)
Output
The length of the question; JS_ERROR on fatal error parsing question.
*/
int decomp_get_question(js_string *compressed, js_string *uncompressed) {
int length;
/* Sanity checks */
if(compressed->unit_count < 12) {
return JS_ERROR;
}
if(uncompressed->unit_count != 12) {
return JS_ERROR;
}
/* Append the dlabel to the uncompressed string */
length = decomp_append_dlabel(compressed,uncompressed,12);
if(length < 1) {
return JS_ERROR;
}
/* Append the type and class to the uncompressed string */
if(decomp_append_bytes(compressed,uncompressed,12 + length,4)
!= JS_SUCCESS) {
return JS_ERROR;
}
length += 4;
return length;
}
/* decomp_init_rrdesc:
Initialize the rr_formats hash
Input
None
Output
JS_ERROR on error
JS_SUCCESS
Global variables affected
rr_formats
*/
int decomp_init_rrdesc() {
int counter;
if((rr_formats = js_alloc(RR_HASH_SIZE,sizeof(rrdesc *))) == 0)
return JS_ERROR;
/* Zero out the hash table */
for(counter = 0; counter < RR_HASH_SIZE; counter++)
rr_formats[counter] = 0;
return JS_SUCCESS;
}
/* decomp_add_rrdesc:
Add a description of a RR to the rr_formats hash
Input
A js_string which describes the record in question
Output
JS_ERROR on error
JS_SUCCESS on success
-2 for error in field 2, -3 for error in field 3, -4 for error in
field 4, and -5 for error in field 5.
Global variables used
rr_formats
*/
int decomp_add_rrdesc(js_string *desc) {
int rtype, place, counter, fieldnum, subfieldnum;
unsigned char c;
rrdesc *new, *point;
/* Sanity checks */
if(js_has_sanity(desc) != JS_SUCCESS)
return JS_ERROR;
js_set_encode(desc,JS_US_ASCII); /* So js_atoi works */
/* Determine where to place this record in the hash */
if((new = js_alloc(1,sizeof(rrdesc))) == 0) {
return JS_ERROR;
}
/* Set up the description. This is a format where the description
of each section of the RR is converted in to a single number */
if((new->description = js_alloc(MAX_RR_SECTIONS,1)) == 0) {
js_dealloc(new);
return JS_ERROR;
}
/* Clear out the new->description array */
for(counter = 0; counter < MAX_RR_SECTIONS - 1; counter++) {
new->description[counter] = 0;
}
/* Initialize the "tocompress" field to uninitialized; this is
a positive number under 127 because some versions of GCC on
some architectures consider 'char' without 'unsigned' an
unsigned value. */
new->tocompress = 79;
/* Now, parse the string describing the message */
fieldnum = subfieldnum = 1;
rtype = -1;
for(counter = 0; counter < desc->unit_count ; counter++) {
c = *(desc->string + counter);
if(fieldnum == 1) { /* RR number field */
if(subfieldnum == 1) /* Before first colon */ {
if(c == ':') {
subfieldnum++;
}
}
else if(subfieldnum == 2) /* Number immediately after colon */ {
if(rtype == -1) {
rtype = js_atoi(desc,counter);
if(rtype <= 0 || rtype > 65535) {
js_dealloc(new->description);
js_dealloc(new);
return JS_ERROR;
}
new->rr_num = rtype;
}
if(c == '|') {
subfieldnum = 1;
fieldnum = 2;
}
}
}
else if(fieldnum == 2) { /* RR name field */
if(c == '|') {
subfieldnum = 1;
fieldnum = 3;
}
}
else if(fieldnum == 3) { /* The description of the RRs themselves */
/* Bounds check */
if(subfieldnum > MAX_RR_SECTIONS - 2) {
js_dealloc(new->description);
js_dealloc(new);
return JS_ERROR;
}
/* Process the RR subfield; this code only supports one-character
labels (quick and dirty; but I want to get 1.0 out the door)
*/
if(new->description[subfieldnum - 1] == 0) {
if(c >= '1' && c <= '9') {
new->description[subfieldnum - 1] = c - '0';
}
else if(c == 'D') {
new->description[subfieldnum - 1] = RRSUB_DLABEL;
}
else if(c == 'T') {
new->description[subfieldnum - 1] = RRSUB_TEXT;
}
else if(c == 'V') {
new->description[subfieldnum - 1] = RRSUB_VARIABLE;
}
else { /* Unknown type */
js_dealloc(new->description);
js_dealloc(new);
return JS_ERROR;
}
}
else if(c != ';' && c != '|') { /* Multi-char description */
js_dealloc(new->description);
js_dealloc(new);
return JS_ERROR;
}
else if(c == ';') {
/* Variable ('V') *must* be the last subfield */
if(new->description[subfieldnum - 1] == RRSUB_VARIABLE) {
js_dealloc(new->description);
js_dealloc(new);
return JS_ERROR;
}
subfieldnum++;
}
else if(c == '|') {
subfieldnum = 1;
fieldnum = 4;
}
else { /* Should never happen */
js_dealloc(new->description);
js_dealloc(new);
return JS_ERROR;
}
}
else if(fieldnum == 4) { /* Whether we can compress this field
or not; currently ignored */
if(c == 'C' && new->tocompress == 79) {
new->tocompress = 1;
}
else if(c == 'N' && new->tocompress == 79) {
new->tocompress = 0;
}
else if(c == '|' && new->tocompress != 79) {
subfieldnum = 1;
fieldnum = 5;
}
else { /* Invalid for field num */
js_dealloc(new->description);
js_dealloc(new);
return -4;
}
}
else if(fieldnum == 5) { /* Description of field; currently
ignored */
/* XXX: We really want something here which makes sure we
have at least three subfields and considers a colon
the start of a new RR */
break;
}
}
/* Now that the new field is set up, add the new element to the
hash of rr descriptions */
place = rtype % RR_HASH_SIZE;
if(rr_formats == 0) {
js_dealloc(new->description);
js_dealloc(new);
return JS_ERROR;
}
point = rr_formats[place];
if(point == 0) {
rr_formats[place] = new;
}
else {
while(point->next != 0)
point = point->next;
point->next = new;
}
new->next = 0;
/* OK, we're done (finally!) */
return JS_SUCCESS;
}
/* decomp_init
Initialize the decompression code; set up the RRs, and set the
log_level global variable in the decompression code.
Input
The desired log_level for all of the decompression code
Output
JS_SUCCESS on success
JS_ERROR on error
Global variables affected
rr_formats (indirectly via decomp_add_rrdesc)
log_level
*/
int decomp_init(int alog_level) {
js_string *temp; /* Used for storing the indivual RR descriptions */
int counter;
/* Create the string */
if((temp = js_create(256,1)) == 0) {
return JS_ERROR;
}
/* Add the records to the big hash */
decomp_init_rrdesc();
for(counter = 0 ; counter < RR_COUNT ; counter++) {
if(js_qstr2js(temp,rr_descs[counter]) != JS_SUCCESS) {
js_destroy(temp);
return JS_ERROR;
}
if(decomp_add_rrdesc(temp) != JS_SUCCESS) {
js_destroy(temp);
return JS_ERROR;
}
}
/* Set the log level */
dlog_level = alog_level;
js_destroy(temp);
return JS_SUCCESS;
}
/* decomp_get_rddesc
Given the rtype (rr_num) (e.g. The resource record number where 1 is A,
etc.), give them a pointer to a null-terminated string which
contains the compiled rr description
Input
The number RR they wish
Output
A pointer to the compiled rr description. 0 if there was any
problem getting that
Global variables used
The "rr_formats" hash
Notes
This string can not be changed; if it is bad things can happen
*/
char *decomp_get_rrdesc(int rr_num) {
rrdesc *point;
if(rr_formats == 0)
return 0;
point = rr_formats[rr_num % RR_HASH_SIZE];
if(point == 0)
return 0;
while(point->rr_num != rr_num) {
point = point->next;
if(point == 0)
return 0;
}
return point->description;
}
/* decomp_get_rddata
Get the rddata from the compressed string, decompressing any dlabels
as needed, and append the data to the uncompressed string.
Input
compressed: The compressed string
out: A js_string object to place the output in
compressed_offset: Where in the string to look (0 is the top of the
string, 1 is the second byte of the string, etc.)
type: The type of resource record (1 for A, 2 for NS, etc.)
rdlength: The rdlength this resource record should have
Output
JS_ERROR on error, JS_SUCCESS if there was no problem processing
*/
int decomp_get_rddata(js_string *compressed, js_string *out,
unsigned int compressed_offset, int type, int rdlength) {
char *desc;
int subtype, total, len;
desc = decomp_get_rrdesc(type);
if(desc == 0) { /* Unknown RR type */
if(rdlength == 0) {
return JS_SUCCESS;
}
if(decomp_append_bytes(compressed,out,compressed_offset,
rdlength) != JS_SUCCESS) {
return JS_ERROR;
}
else {
return JS_SUCCESS;
}
}
else {
subtype = *desc;
total = 0;
/* Handle the various types of data we can get in the RR RDDATA */
while(subtype != 0) {
/* Fix-length data fields */
if(subtype > 0 && subtype < 64) {
if(decomp_append_bytes(compressed,out,
compressed_offset,subtype) != JS_SUCCESS) {
return JS_ERROR;
}
total += subtype;
compressed_offset += subtype;
}
/* Dlabels (which may be compressed) */
else if(subtype == RRSUB_DLABEL) {
len = decomp_append_dlabel(compressed,out,
compressed_offset);
if(len == JS_ERROR) {
return JS_ERROR;
}
total += len;
compressed_offset += len;
}
/* Text data fields */
else if(subtype == RRSUB_TEXT) {
/* Data abstraction violation */
len = *(compressed->string + compressed_offset);
len += 1; /* To account for the one byte which
describes the length */
if(len < 0 || len > 256) {
return JS_ERROR;
}
if(decomp_append_bytes(compressed,out,
compressed_offset,len) !=
JS_SUCCESS) {
return JS_ERROR;
}
total += len;
compressed_offset += len;
}
/* Variable length data (length determined by rdlength) */
else if(subtype == RRSUB_VARIABLE) {
len = rdlength - total;
if(len <= 0) {
break;
}
if(decomp_append_bytes(compressed,out,
compressed_offset,len) != JS_SUCCESS) {
return JS_ERROR;
}
total += len;
compressed_offset += len;
}
else { /* Should never happen */
return JS_ERROR;
}
desc++;
/* RRSUB_VARIABLE must be the last subtype */
if(subtype != RRSUB_VARIABLE)
subtype = *desc;
else
subtype = 0; /* break the loop */
}
/* Sanity check; make sure that rdlength panned out */
if(rdlength != total) {
return JS_ERROR;
}
}
/* The record's rddata was sucessfully decompressed */
return JS_SUCCESS;
}
/* decomp_decompress_packet
Uncompressed a query (or reply) compressed with the RFC1035 compression
alogrithm (see RFC1035 4.1.4)
Input
Pointer to compressed DNS packet
Pointer to uncompressed DNS packet
Output
JS_ERROR on error
JS_SUCCESS on success
*/
int decomp_decompress_packet(js_string *compressed, js_string *uncompressed) {
int answers; /* Number of answers */
int type, rdlength; /* As per RFC1035 3.2.1 */
int offset,length;
js_string *rddata;
/* Sanity checks */
if(js_has_sanity(compressed) == JS_ERROR)
return JS_ERROR;
if(js_has_sanity(uncompressed) == JS_ERROR)
return JS_ERROR;
if(compressed->unit_size != 1 || uncompressed->unit_size != 1)
return JS_ERROR;
if(uncompressed->unit_count != 0)
return JS_ERROR;
/* Create the string for storing the rddata */
#ifndef AUTHONLY
if((rddata = js_create(512,1)) == 0) {
return JS_ERROR;
}
#else
if((rddata = js_create(4512,1)) == 0) {
return JS_ERROR;
}
#endif
/* Read the header */
answers = decomp_get_header(compressed,uncompressed);
if(answers == -2) { /* No questions and no answers */
js_destroy(rddata);
return JS_SUCCESS;
}
else if(answers == JS_ERROR) {
js_destroy(rddata);
return JS_ERROR;
}
/* Process the question (if applicable) */
if(answers <= -3) {
answers = -2 - answers; /* So -3 becomes 1 answer, -4 becomes
2 answers, etc. */
length = 0;
}
else {
length = decomp_get_question(compressed,uncompressed);
if(length < 1) {
js_destroy(rddata);
return JS_ERROR;
}
}
offset = 12 + length;
/* Process the answers */
while(answers > 0) {
length = decomp_append_dlabel(compressed,uncompressed,offset);
if(length < 1) {
js_destroy(rddata);
return JS_ERROR;
}
offset += length;
type = decomp_get_type_etc(compressed,uncompressed,offset);
if(type == JS_ERROR) {
js_destroy(rddata);
return JS_ERROR;
}
offset += 8;
rdlength = decomp_get_rdlength(compressed,offset);
if(rdlength == JS_ERROR) {
js_destroy(rddata);
return JS_ERROR;
}
offset += 2;
/* Hack: zero out the rddata string */
rddata->unit_count = 0;
if(decomp_get_rddata(compressed,rddata,offset,type,rdlength)
!= JS_SUCCESS) {
js_destroy(rddata);
return JS_ERROR;
}
/* Add the decompressed rdlength */
if(js_adduint16(uncompressed,rddata->unit_count) == JS_ERROR) {
js_destroy(rddata);
return JS_ERROR;
}
/* And the decompressed rddata */
if(js_append(rddata,uncompressed) == JS_ERROR) {
js_destroy(rddata);
return JS_ERROR;
}
offset += rdlength; /* The compressed rdlength */
answers--;
}
js_destroy(rddata);
return JS_SUCCESS;
}
/* decompress_data
This and the decomp_init function are the only functions which should
be visible to other code; the only "public methods" so to speak
Input
compressed string, uncompressed string
Output
JS_ERROR on error, JS_SUCCESS on success
*/
int decompress_data(js_string *compressed, js_string *uncompressed) {
/* zero-out the uncompressed string */
uncompressed->unit_count = 0;
if(dlog_level >= 5) {
printf("About to decompress packet: ");
show_esc_stdout(compressed);
printf("\n");
}
if(dlog_level == -1) { /* Uninitialized, return error */
return JS_ERROR;
}
else {
return decomp_decompress_packet(compressed,uncompressed);
}
/* We should never end up here */
return JS_ERROR;
}
/* Since the compression code needs to use the same rr_formats database,
this bit of code exports the rr_formats hash so that the compression
code can use it */
rrdesc **decomp_export_rrformats() {
return rr_formats;
}