compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
{
j_lossless_c_ptr losslsc = (j_lossless_c_ptr) cinfo->codec;
c_diff_ptr diff = (c_diff_ptr) losslsc->diff_private;
/* JDIMENSION MCU_col_num; */ /* index of current MCU within row */
/* JDIMENSION MCU_count; */ /* number of MCUs encoded */
int comp, ci /* , yoffset */ ;
JSAMPARRAY buffer[MAX_COMPONENTS];
jpeg_component_info *compptr;
/* Align the virtual buffers for the components used in this scan.
* NB: during first pass, this is safe only because the buffers will
* already be aligned properly, so jmemmgr.c won't need to do any I/O.
*/
for (comp = 0; comp < cinfo->comps_in_scan; comp++) {
compptr = cinfo->cur_comp_info[comp];
ci = compptr->component_index;
buffer[ci] = (*cinfo->mem->access_virt_sarray)
((j_common_ptr) cinfo, diff->whole_image[ci],
diff->iMCU_row_num * compptr->v_samp_factor,
(JDIMENSION) compptr->v_samp_factor, FALSE);
}
return compress_data(cinfo, buffer);
}
/*
* One 4-byte pointer per block and then the actual blocked
* output. The first block does not need an offset pointer,
* as it will start immediately after the pointer block;
* so the i'th pointer points to the end of the i'th block
* (i.e. the start of the (i+1)'th block or past EOF).
*
* Note that size > 0, as a zero-sized file wouldn't ever
* have gotten here in the first place.
*/
static unsigned int do_compress(char *base, unsigned int offset, char const *name, char *uncompressed, unsigned int size)
{
unsigned long original_size = size;
unsigned long original_offset = offset;
unsigned long new_size;
unsigned long blocks = (size - 1) / blksize + 1;
unsigned long curr = offset + 4 * blocks;
int change;
total_blocks += blocks;
do {
unsigned long len = 2 * blksize;
unsigned int input = size;
int err;
if (input > blksize)
input = blksize;
size -= input;
if (!(opt_holes && is_zero (uncompressed, input))) {
err = compress_data(base + curr, &len, uncompressed,
input, Z_BEST_COMPRESSION);
if (err != Z_OK) {
die(MKFS_ERROR, 0, "compression error: %s", zError(err));
}
curr += len;
}
uncompressed += input;
if (len > blksize*2) {
/* (I don't think this can happen with zlib.) */
die(MKFS_ERROR, 0, "AIEEE: block \"compressed\" to > 2*blocklength (%ld)", len);
}
*(u32 *) (base + offset) = CRAMFS_32(curr);
offset += 4;
} while (size);
curr = (curr + 3) & ~3;
new_size = curr - original_offset;
/* TODO: Arguably, original_size in these 2 lines should be
st_blocks * 512. But if you say that then perhaps
administrative data should also be included in both. */
change = new_size - original_size;
if (opt_verbose > 1) {
printf("%6.2f%% (%+d bytes)\t%s\n",
(change * 100) / (double) original_size, change, name);
}
return curr;
}
int PT_find_exProb(PT_exProb *pep, int) {
POS_TREE *pt = ptstruct.pt; // start search at root
GBS_strstruct *gbs_str = GBS_stropen(pep->numget * (pep->plength + 1) + 1);
bool first = true;
for (int c = 0; c < pep->numget; ++c) {
bool found = false;
if (pep->restart) {
pep->restart = 0;
char *probe = (char*) malloc(pep->plength + 1);
memset(probe, 'N', pep->plength);
probe[pep->plength] = 0; // EOS marker
compress_data(probe);
pep->next_probe.data = probe;
pep->next_probe.size = pep->plength + 1;
found = findLeftmostProbe(pt, pep->next_probe.data, pep->plength,
0);
assert(pep->next_probe.data[pep->plength] == 0);
assert(strlen(pep->next_probe.data) == (size_t) pep->plength);
}
if (!found) {
found = findNextProbe(pt, pep->next_probe.data, pep->plength, 0);
assert(pep->next_probe.data[pep->plength] == 0);
assert(strlen(pep->next_probe.data) == (size_t) pep->plength);
}
if (!found)
break;
// append the probe to the probe list
if (!first)
GBS_strcat(gbs_str, ";");
first = false;
GBS_strcat(gbs_str, pep->next_probe.data);
}
pep->result = GBS_strclose(gbs_str);
return 0;
}
int write_tensor(datatensor& tensor, FILE* file){
// write tensor's name
uint8_t namelen = tensor.name ? strlen(tensor.name) : 0;
fwrite(&namelen, sizeof(uint8_t), 1, file);
if(tensor.name){
if(VERBOSE){ std::cout << "# name : " << tensor.name << std::endl; }
fwrite(tensor.name, sizeof(char), namelen, file);
}
// write the tensor's rank
if(VERBOSE){ std::cout << "# rank : " << ((int)tensor.rank) << std::endl; }
fwrite(&(tensor.rank), sizeof(uint8_t), 1, file);
// write the length of each dimmension
if(VERBOSE){ std::cout << "# lengths : "; for(int i=0; i < tensor.rank; i++){ std::cout << tensor.lengths[i] << " "; } std::cout << std::endl; }
fwrite(tensor.lengths, sizeof(unsigned int), tensor.rank, file);
// write the element type stuct
if(!write_tensor_type(tensor.type, file)){
return UNSUPPORTED_ELEMENT_TYPE;
}
// write the data (possibly compressed)
{
bool cdata_is_temp=false;
unsigned int cdata_length=0;
uint8_t* cdata=0;
if(!tensor.data){
return INVALID_STRUCT;
}
if(!compress_data(tensor, &cdata, &cdata_length, &cdata_is_temp)){
if(VERBOSE){ std::cout << "# cdata size: " << cdata_length << std::endl; }
return UNSUPPORTED_COMPRESS_TYPE;
}
uint8_t ctype = (uint8_t)tensor.compression;
fwrite(&ctype, sizeof(uint8_t), 1, file);
if(VERBOSE){ std::cout << "# cdata size: " << cdata_length << std::endl; }
fwrite(&cdata_length, sizeof(unsigned int), 1, file);
if(VERBOSE){ std::cout << "# cdata : " << ((void*)cdata) << std::endl; }
fwrite(cdata, cdata_length, 1, file);
if(cdata_is_temp){
if(VERBOSE){ std::cout << "# deleting temp cdata... " << cdata << std::endl; }
delete[] cdata;
}
}
return SUCCESS;
}
static void send_trace_log (std::map<MonoMethod*, CallInfo> const &dict) {
MemWriter sbuf(0x100000);
MemWriter writer(0x100000);
std::map<MonoMethod*, CallInfo>::const_iterator p;
for (p = dict.begin (); p != dict.end (); p++) {
MonoMethod *method = p->first;
CallInfo call_info = p->second;
char const *m = get_method_image_name (method);
char *n = mono_method_full_name (method, 0);
char str[256];
sbuf.sprintf ("[%s] %s [%08X]|%d|%d\n", m, n, mono_method_get_token (method), call_info.times, call_info.order);
g_free (n);
}
if (!compress_data (sbuf.getBuffPtr (), sbuf.getBuffSize (), &writer)) {
LOGD ("compress_data err!");
return;
}
/*Fixme : 这里写在使用protocolbuf之前, 因此非常不河蟹的出现了不使用pb的封包*/
ecmd_send (XMONO_ID_TRACE_REPORT, writer.getBuffPtr (), writer.getBuffSize ());
return;
}
/*
* Handle the data just read and send it to the SD after doing any postprocessing needed.
*/
static inline bool send_data_to_sd(b_ctx *bctx)
{
BSOCK *sd = bctx->jcr->store_bsock;
bool need_more_data;
/*
* Check for sparse blocks
*/
if (bit_is_set(FO_SPARSE, bctx->ff_pkt->flags)) {
bool allZeros;
ser_declare;
allZeros = false;
if ((sd->msglen == bctx->rsize &&
(bctx->fileAddr + sd->msglen < (uint64_t)bctx->ff_pkt->statp.st_size)) ||
((bctx->ff_pkt->type == FT_RAW ||
bctx->ff_pkt->type == FT_FIFO) &&
((uint64_t)bctx->ff_pkt->statp.st_size == 0))) {
allZeros = is_buf_zero(bctx->rbuf, bctx->rsize);
}
if (!allZeros) {
/*
* Put file address as first data in buffer
*/
ser_begin(bctx->wbuf, OFFSET_FADDR_SIZE);
ser_uint64(bctx->fileAddr); /* store fileAddr in begin of buffer */
}
bctx->fileAddr += sd->msglen; /* update file address */
/*
* Skip block of all zeros
*/
if (allZeros) {
return true;
}
} else if (bit_is_set(FO_OFFSETS, bctx->ff_pkt->flags)) {
ser_declare;
ser_begin(bctx->wbuf, OFFSET_FADDR_SIZE);
ser_uint64(bctx->ff_pkt->bfd.offset); /* store offset in begin of buffer */
}
bctx->jcr->ReadBytes += sd->msglen; /* count bytes read */
/*
* Uncompressed cipher input length
*/
bctx->cipher_input_len = sd->msglen;
/*
* Update checksum if requested
*/
if (bctx->digest) {
crypto_digest_update(bctx->digest, (uint8_t *)bctx->rbuf, sd->msglen);
}
/*
* Update signing digest if requested
*/
if (bctx->signing_digest) {
crypto_digest_update(bctx->signing_digest, (uint8_t *)bctx->rbuf, sd->msglen);
}
/*
* Compress the data.
*/
if (bit_is_set(FO_COMPRESS, bctx->ff_pkt->flags)) {
if (!compress_data(bctx->jcr, bctx->ff_pkt->Compress_algo, bctx->rbuf,
bctx->jcr->store_bsock->msglen, bctx->cbuf,
bctx->max_compress_len, &bctx->compress_len)) {
return false;
}
/*
* See if we need to generate a compression header.
*/
if (bctx->chead) {
ser_declare;
/*
* Complete header
*/
ser_begin(bctx->chead, sizeof(comp_stream_header));
ser_uint32(bctx->ch.magic);
ser_uint32(bctx->compress_len);
ser_uint16(bctx->ch.level);
ser_uint16(bctx->ch.version);
ser_end(bctx->chead, sizeof(comp_stream_header));
bctx->compress_len += sizeof(comp_stream_header); /* add size of header */
}
bctx->jcr->store_bsock->msglen = bctx->compress_len; /* set compressed length */
bctx->cipher_input_len = bctx->compress_len;
}
/*
* Encrypt the data.
*/
need_more_data = false;
if (bit_is_set(FO_ENCRYPT, bctx->ff_pkt->flags) && !encrypt_data(bctx, &need_more_data)) {
if (need_more_data) {
return true;
}
return false;
}
/*
* Send the buffer to the Storage daemon
*/
if (bit_is_set(FO_SPARSE, bctx->ff_pkt->flags) || bit_is_set(FO_OFFSETS, bctx->ff_pkt->flags)) {
sd->msglen += OFFSET_FADDR_SIZE; /* include fileAddr in size */
}
sd->msg = bctx->wbuf; /* set correct write buffer */
if (!sd->send()) {
if (!bctx->jcr->is_job_canceled()) {
Jmsg1(bctx->jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"), sd->bstrerror());
}
return false;
}
Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
bctx->jcr->JobBytes += sd->msglen; /* count bytes saved possibly compressed/encrypted */
sd->msg = bctx->msgsave; /* restore read buffer */
return true;
}
int udpsuccess(rr *where, int id, int sock, struct sockaddr_in *client,
js_string *query, void **rotate_point, int show_cname_a,
int rd_val, conn *ect, int force_authoritative,int ra_value) {
js_string *most = 0; /* Most of the data */
js_string *ar = 0; /* Then the additional records */
uint16 first_rr_type;
int in_ns = 0;
int ns_delegation = 0;
int length_save;
int len_inet = sizeof(struct sockaddr);
rr *ipwhere = 0;
/* The following are used for round robin rotation */
rr *rotate_1st = 0, *rotate_2nd = 0, *rotate_last = 0;
/* Counters in ensure that we don't give out more than the maximum
number of A, AN (A), chain, or total records */
int a_count = 0, an_count = 0;
fila *zap_point;
/* These two variables are added to handle PTR records */
int seen_ptr_record = 0;
rr *top = where;
int is_auth = 0;
int compress_error_happened = 0;
q_header header;
/* Initialize the total count */
total_count = 0;
/* Initialize the js_string objects */
if((most = js_create(1024,1)) == 0)
return JS_ERROR;
#ifdef AUTHONLY
if((ar = js_create(5000,1)) == 0) {
js_destroy(most);
return JS_ERROR;
}
#else
if((ar = js_create(600,1)) == 0) {
js_destroy(most);
return JS_ERROR;
}
#endif
/* Make the header a placeholder for now */
init_header(&header);
header.id = id;
if(make_hdr(&header,most) == JS_ERROR)
goto giveerror;
/* Sanity check */
if(where == 0) {
goto giveerror;
}
if(where->query == 0) {
goto giveerror;
}
if(js_has_sanity(where->query) == JS_ERROR) {
goto giveerror;
}
if(where->data == 0) {
goto giveerror;
}
if(js_has_sanity(where->data) == JS_ERROR) {
goto giveerror;
}
if(js_has_sanity(query) == JS_ERROR) {
goto giveerror;
}
first_rr_type = get_rtype(query);
/* Somewhat hacky way to determine that this is a NS delegation */
ns_delegation = 0;
if(first_rr_type != RR_NS && where->rr_type == RR_NS) {
ns_delegation = 1;
}
/* With the cache, this may be a rtype of RR_ANY. We need to handle
this special case */
/* We have to add this header here--authoritative depends on the
authorative status of the first record we find */
if(force_authoritative != 1) {
header.aa = where->authoritative;
}
else {
header.aa = 1;
}
is_auth = where->authoritative;
/* The data must be between 0 and 65535 bytes in length (16-bit
unsigned value) */
if(where->data->unit_count < 0 || where->data->unit_count > 65535) {
goto giveerror;
}
/* Append the question to the answer */
if(js_append(query,most) == JS_ERROR) {
goto giveerror;
}
/* Append the class (in) to the answer */
if(js_adduint16(most,1) == JS_ERROR) {
goto giveerror;
}
/* We will increment the ancount, nscount, an arcount, starting at 0 */
header.ancount = 0;
header.nscount = 0;
header.arcount = 0;
/* Initialize some temporary pointers used for round robin rotation */
rotate_1st = where;
rotate_2nd = where->next;
/* We do not round robin if there is but a single record */
if(rotate_2nd != 0 && first_rr_type != RR_NS &&
rotate_2nd->rr_type == RR_NS)
rotate_2nd = 0;
/* OK, we now add the answers */
while(where != 0) {
/* Increment the number of answers -or- ns records */
if(first_rr_type != RR_NS && where->rr_type == RR_NS && in_ns == 0) {
/* Due to the data structure MaraDNS currently uses, the behavior
is buggy if we round-robin rotate data when we allow more than
one additional record to be create per answer/authoritative
record. */
if(rotate_2nd != 0 && max_ar_chain == 1 && rotate_last != 0 &&
first_rr_type != RR_NS) {
/* If it makes sense to do a round-robin rotation, do so.
* Make rotate_1st, which was the first record, the last
* record; make rotate_2nd, which was the second record,
* the first record; and make rotate_last, which is the last
* record in the chain, have its next record be the first
* record */
rotate_1st->next = where;
rotate_last->next = rotate_1st;
*rotate_point = rotate_2nd;
rotate_2nd = 0; /* Make sure we can not rotate again */
}
in_ns = 1;
a_count = 0; /* The NS chain is different than the AN
chain of answers: If we only allow eight
answers in a chain, we can still have 16
answers: 8 records in the answer section then
8 records in the authority section */
}
if(a_count < max_chain && total_count < max_total && (in_ns == 0
|| is_auth == 1 || ns_delegation == 1)) {
a_count++;
total_count++;
if(!in_ns) {
header.ancount++;
}
else {
header.nscount++;
}
/* Append the name for this answer to the answer */
if(js_append(where->query,most) == JS_ERROR)
goto giveerror;
/* Append the class (in) to the answer */
if(js_adduint16(most,1) == JS_ERROR)
goto giveerror;
/* Append the ttl to the answer */
if(js_adduint32(most,determine_ttl(where->expire,where->ttl))
== JS_ERROR)
goto giveerror;
/* Add the rdlength to the answer */
if(js_adduint16(most,where->data->unit_count) == JS_ERROR)
goto giveerror;
/* Add the record itself to the answer */
if(js_append(where->data,most) == JS_ERROR)
goto giveerror;
/* If there is an IP, and this is *not* a CNAME record,
append the IP of the answer to the AR section */
if(where->ip != 0 && where->rr_type != RR_CNAME) {
/* Reset the number of an records we have seen */
an_count = 0;
ipwhere = where->ip;
while(ipwhere != 0 && ipwhere->rr_type != RR_NS) {
/* We only show a given additional record once */
if(ipwhere->seen == 1) { /* If we have displayed this RR
already */
/* Go to the next link in the linked list */
ipwhere = ipwhere->next;
continue;
}
/* Stop showing records if we have exceeded our limit */
if(an_count >= max_ar_chain || total_count >= max_total)
break;
an_count++;
total_count++;
/* Increment the number of additional records */
header.arcount++;
/* Append the name for this answer to the ip */
if(js_append(ipwhere->query,ar) == JS_ERROR)
goto giveerror;
/* Append the class (in) to the ip */
if(js_adduint16(ar,1) == JS_ERROR)
goto giveerror;
/* Append the TTL to the ip */
if(js_adduint32(ar,
determine_ttl(ipwhere->expire,ipwhere->ttl)) == JS_ERROR)
goto giveerror;
/* Add the rdlength to the ip */
if(js_adduint16(ar,ipwhere->data->unit_count) == JS_ERROR)
goto giveerror;
/* Add the record itself to the ip */
if(js_append(ipwhere->data,ar) == JS_ERROR)
goto giveerror;
/* Mark that we have seen this record already */
if(seenlist_where < 250) {
ipwhere->seen = 1;
seenlist[seenlist_where] = ipwhere;
seenlist_where++;
}
/* Go to the next link in the linked list */
ipwhere = ipwhere->next;
}
}
#ifdef IPV6
if(where->ip6 != 0 && where->rr_type != RR_CNAME) {
/* Reset the number of an records we have seen */
an_count = 0;
ipwhere = where->ip6;
while(ipwhere != 0 && ipwhere->rr_type != RR_NS) {
/* We only show a given additional record once */
if(ipwhere->seen == 1) { /* If we have displayed this RR
already */
/* Go to the next link in the linked list */
ipwhere = ipwhere->next;
continue;
}
/* Stop showing records if we have exceeded our limit */
if(an_count >= max_ar_chain || total_count >= max_total)
break;
an_count++;
total_count++;
/* Increment the number of additional records */
header.arcount++;
/* Append the name for this answer to the ip */
if(js_append(ipwhere->query,ar) == JS_ERROR)
goto giveerror;
/* Append the class (in) to the ip */
if(js_adduint16(ar,1) == JS_ERROR)
goto giveerror;
/* Append the TTL to the ip */
if(js_adduint32(ar,
determine_ttl(ipwhere->expire,ipwhere->ttl)) == JS_ERROR)
goto giveerror;
/* Add the rdlength to the ip */
if(js_adduint16(ar,ipwhere->data->unit_count) == JS_ERROR)
goto giveerror;
/* Add the record itself to the ip */
if(js_append(ipwhere->data,ar) == JS_ERROR)
goto giveerror;
/* Mark that we have seen this record already */
if(seenlist_where < 250) {
ipwhere->seen = 1;
seenlist[seenlist_where] = ipwhere;
seenlist_where++;
}
/* Go to the next link in the linked list */
ipwhere = ipwhere->next;
}
}
#endif
/* This code is only used by the recursive code; the
* authoritative code now uses where->list to attach
* a CNAME record to its corresponding rddata
* If there is an IP, and this is a CNAME record, and
* show_cname_a is set to one (argument to this function)
* append the IP in question to the answer section */
if(where->ip != 0 && where->rr_type == RR_CNAME
&& show_cname_a == RR_A && where->list == 0) {
/* Reset the number of an records we have seen */
an_count = 0;
ipwhere = where->ip;
while(ipwhere != 0 && ipwhere->rr_type != RR_NS) {
/* We only show a given additional record once */
if(ipwhere->seen == 1) { /* If we have displayed this RR
already */
/* Go to the next link in the linked list */
ipwhere = ipwhere->next;
continue;
}
/* If the IP in question is 255.255.255.255, we do
not show the data in question */
if(ipwhere->rr_type == RR_A &&
ipwhere->data->unit_count == 4 &&
*(ipwhere->data->string) == 0xff &&
*(ipwhere->data->string + 1) == 0xff &&
*(ipwhere->data->string + 2) == 0xff &&
*(ipwhere->data->string + 3) == 0xff) {
ipwhere = ipwhere->next;
continue;
}
/* Stop showing records if we have exceeded our limit */
if(an_count >= max_ar_chain || total_count >= max_total)
break;
an_count++;
total_count++;
/* Increment the number of answer records */
header.ancount++;
/* Append the name for this answer to the ip */
if(js_append(ipwhere->query,most) == JS_ERROR)
goto giveerror;
/* Append the class (in) to the ip */
if(js_adduint16(most,1) == JS_ERROR)
goto giveerror;
/* Append the TTL to the ip */
if(js_adduint32(most,
determine_ttl(ipwhere->expire,ipwhere->ttl)) == JS_ERROR)
goto giveerror;
/* Add the rdlength to the ip */
if(js_adduint16(most,ipwhere->data->unit_count)
== JS_ERROR)
goto giveerror;
/* Add the record itself to the ip */
if(js_append(ipwhere->data,most) == JS_ERROR)
goto giveerror;
/* Mark that we have seen this record already */
if(seenlist_where < 250) {
ipwhere->seen = 1;
seenlist[seenlist_where] = ipwhere;
seenlist_where++;
}
/* Go to the next link in the linked list */
ipwhere = ipwhere->next;
}
}
/* Again, this code is only used by the recursive half.
* The authoritative half now has a way of showing the record
* that correspods to any RR type attached to a CNAME record.
*
* If there is an PTR, and this is a CNAME record, and
* show_cname_a is set to one (argument to this function)
* append the IP in question to the answer section */
else if(top->ptr != 0 && top->rr_type == RR_CNAME
&& show_cname_a == RR_PTR && seen_ptr_record == 0
&& where->list == 0) {
/* Mark that we have seen this record already */
seen_ptr_record = 1;
/* Increment the total number of answers seen */
total_count++;
/* Increment the number of answer records */
header.ancount++;
/* Append the name for this answer to the ip */
if(js_append(top->data,most) == JS_ERROR)
goto giveerror;
/* Append the type for this query */
if(js_adduint16(most,RR_PTR) == JS_ERROR)
goto giveerror;
/* Append the class (in) to the ip */
if(js_adduint16(most,1) == JS_ERROR)
goto giveerror;
/* Append the TTL to the ip */
if(js_adduint32(most,
determine_ttl(top->expire,top->ttl)) == JS_ERROR)
goto giveerror;
/* Add the rdlength to the ip */
if(js_adduint16(most,top->ptr->unit_count)
== JS_ERROR)
goto giveerror;
/* Add the record itself to the ip */
if(js_append(top->ptr,most) == JS_ERROR)
goto giveerror;
}
/* This code is currently only used by the authoritative half;
* bascially, if we see a CNAME record we see if we have a list
* which lists all record types for the host name the CNAME
* is pointing to. We used this list to add, in the answer
* section, the answer the person is looking for. */
else if(where->rr_type == RR_CNAME && where->list != 0) {
struct rr_list *any_list = 0;
uint16 this_rr_type = 0;
int counter = 0;
/* Start at the top of list of RRs */
any_list = where->list;
this_rr_type = first_rr_type; /* The rtype they want */
/* We go down the list until we find the desired rr_type */
for(counter = 0; counter < 1000; counter++) {
if(any_list->rr_type == this_rr_type) {
break;
}
if(any_list->next == 0) {
break;
}
any_list = any_list->next;
}
/* If we found the desired record type... */
if(any_list->rr_type == this_rr_type && any_list->data != 0) {
rr *answer;
int counter = 0;
answer = any_list->data;
while(answer != 0 && answer->rr_type == this_rr_type &&
counter < 100) {
/* Then we add this information to the AN section of
* the answer */
/* Increase the number of answers in the header */
header.ancount++;
/* RFC 1035 section 3.2.1 header */
/* Name + Type */
if(js_append(answer->query,most) == JS_ERROR)
goto giveerror;
/* Class */
if(js_adduint16(most,1) == JS_ERROR)
goto giveerror;
/* TTL */
/* Since this currently only returns authoritative
* data, answer->expire should always be zero and
* determine_ttl is a redundant call. However, we'll
* keep it that way just in case things change in
* the future */
if(js_adduint32(most,determine_ttl(answer->expire,
answer->ttl)) == JS_ERROR)
goto giveerror;
/* Rdlength */
if(answer->data == 0)
goto giveerror;
if(answer->data->unit_count < 0 ||
answer->data->unit_count > 65535)
goto giveerror;
if(js_adduint16(most,answer->data->unit_count) ==
JS_ERROR)
goto giveerror;
/* rdata */
if(js_append(answer->data,most) == JS_ERROR)
goto giveerror;
counter++;
answer = answer->next;
}
}
}
}
/* Go on to the next record in the linked list */
rotate_last = where;
where = where->next;
/* If it makes sense to do a round-robin rotation, do so */
if(where == 0 && rotate_2nd != 0 && max_ar_chain == 1 &&
first_rr_type != RR_NS) {
/* For records in the cache, we need to make sure that
the custodian properly points to the first record
in the chain or we will leak memory */
if(rotate_1st->zap != 0) {
zap_point = rotate_1st->zap;
rotate_1st->zap = 0;
rotate_2nd->zap = zap_point;
zap_point->record = rotate_2nd;
}
rotate_1st->next = 0;
rotate_last->next = rotate_1st;
*rotate_point = rotate_2nd;
rotate_2nd = 0; /* Make sure we can not rotate again */
}
}
/* Customize the header */
/* header.id already set */
header.qr = 1;
header.opcode = 0;
header.tc = 0;
header.rd = rd_val; /* RDBUG udpsuccess */
header.ra = calc_ra_value(ra_value);
header.z = 0;
header.rcode = 0; /* No error */
header.qdcount = 1;
/* OBhack: Tack on the header at the beginning without molesting the
rest of the string */
length_save = most->unit_count;
make_hdr(&header,most);
most->unit_count = length_save;
/* Add the ar records to the end */
if(js_append(ar,most) == JS_ERROR) {
goto giveerror;
}
compress_error_happened = 0;
if(compress_data(most,ar) == JS_ERROR) {
compress_error_happened = 1;
}
/* Check to make sure the data fits in under 512 bytes (4096 bytes
* if it's a long_packet_ipv4 address) truncate if not */
if(ar->unit_count > 512 || compress_error_happened == 1) {
int x;
#ifdef AUTHONLY
/* If this is an ipv4 connection and we didn't get a compress error */
if(ect->type == 4 && compress_error_happened == 0) {
struct sockaddr_in *dq;
uint32 ip_test;
dq = (struct sockaddr_in *)(ect->d);
ip_test = ntohl(dq->sin_addr.s_addr);
/* See if we are allowed to send a long packet up to
* 4096 bytes to this ip address */
if(check_ipv4_acl(ip_test,long_packet) == 1) {
if(ar->unit_count < 4096) {
goto long_packet_ok;
}
}
}
#endif
for(x = 0; x < 20; x++) {
compress_error_happened = 0;
/* OK, try to squeeze the packet in by removing records */
if(squeeze_to_fit(most) == 0) {
goto giveerror;
}
if(most->unit_count > 12) {
if(compress_data(most,ar) == JS_ERROR) {
compress_error_happened = 1;
}
if(ar->unit_count <= 512 &&
compress_error_happened == 0) {
break;
}
} else if(most->unit_count == 12) {
if(js_copy(most,ar) == JS_ERROR) {
goto giveerror;
}
} else {
goto giveerror;
}
}
}
#ifdef AUTHONLY
long_packet_ok:
#endif
if(compress_error_happened == 1) {
goto giveerror;
}
/* Success! Put out the good data */
if(ect == 0) {
sendto(sock,ar->string,ar->unit_count,0,
(struct sockaddr *)client,len_inet);
} else {
mara_send(ect,sock,ar);
}
js_destroy(most);
js_destroy(ar);
/* Clean up the seenlist_where list */
while(seenlist_where > 0) {
seenlist_where--;
if(seenlist[seenlist_where] != 0)
(seenlist[seenlist_where])->seen = 0;
}
return JS_SUCCESS;
/* We use gotos to make up for C's lack of error trapping */
giveerror:
js_destroy(ar);
udperror(sock,most,client,0,SERVER_FAIL,"giveerror in udpsuccess",2,
rd_val,ect,1);
js_destroy(most);
/* Clean up the seenlist_where list */
while(seenlist_where > 0) {
seenlist_where--;
if(seenlist[seenlist_where] != 0)
(seenlist[seenlist_where])->seen = 0;
}
return JS_ERROR;
}
int main(int argc,char *argv[])
{
FILE *fpout;
char *tag;
int c;
int level;
fpout = stdout;
tag = "data";
level = 0;
while((c = getopt(argc,argv,"o:t:hz0123456789")) != EOF)
{
switch(c)
{
default:
case 'h':
fprintf(stderr,"usage: %s [-o output] [-t tag] [-z] [-h] files... \n",argv[0]);
return EXIT_FAILURE;
case 't':
tag = optarg;
for ( ; *optarg ; optarg++)
if (*optarg == '-')
*optarg = '_';
break;
case 'o':
fpout = fopen(optarg,"wb");
if (fpout == NULL)
{
perror(optarg);
exit(EXIT_FAILURE);
}
break;
case 'z':
level = Z_DEFAULT_COMPRESSION;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
level = c - '0';
break;
}
}
if (optind == argc)
{
fprintf(stderr,"usage: %s [-o output] [-t tag] [-z] [-h] files... \n",argv[0]);
return EXIT_FAILURE;
}
else
{
for (int i = optind ; i < argc ; i++)
{
unsigned char *data;
size_t datasize;
size_t realdatasize;
int rc;
rc = load_file(argv[i],&data,&realdatasize);
if (rc != 0)
{
fprintf(stderr,"%s: %s\n",argv[i],strerror(rc));
free(data);
return EXIT_FAILURE;
}
rc = compress_data(level,&data,realdatasize,&datasize);
if (rc != 0)
{
fprintf(stderr,"%s: %s\n",argv[1],strerror(rc));
free(data);
return EXIT_FAILURE;
}
process(fpout,data,datasize,realdatasize,tag);
free(data);
}
}
return EXIT_SUCCESS;
}
/*
* Perform automatic compression of certain stream types when enabled in the config.
*/
static bool auto_deflate_record(DCR *dcr)
{
ser_declare;
comp_stream_header ch;
DEV_RECORD *rec, *nrec;
bool retval = false;
bool intermediate_value = false;
unsigned int max_compression_length = 0;
unsigned char *data = NULL;
/*
* See what our starting point is. When dcr->after_rec is set we already have
* a translated record by an other SD plugin. Then we use that translated record
* as the starting point otherwise we start at dcr->before_rec. When an earlier
* translation already happened we can free that record when we have a success
* full translation here as that record is of no use anymore.
*/
if (dcr->after_rec) {
rec = dcr->after_rec;
intermediate_value = true;
} else {
rec = dcr->before_rec;
}
/*
* We only do autocompression for the following stream types:
*
* - STREAM_FILE_DATA
* - STREAM_WIN32_DATA
* - STREAM_SPARSE_DATA
*/
switch (rec->maskedStream) {
case STREAM_FILE_DATA:
case STREAM_WIN32_DATA:
case STREAM_SPARSE_DATA:
break;
default:
goto bail_out;
}
/*
* Clone the data from the original DEV_RECORD to the converted one.
* As we use the compression buffers for the data we need a new
* DEV_RECORD without a new memory buffer so we call new_record here
* with the with_data boolean set explicitly to false.
*/
nrec = bfuncs->new_record(false);
bfuncs->copy_record_state(nrec, rec);
/*
* Setup the converted DEV_RECORD to point with its data buffer to the compression buffer.
*/
nrec->data = dcr->jcr->compress.deflate_buffer;
switch (rec->maskedStream) {
case STREAM_FILE_DATA:
case STREAM_WIN32_DATA:
data = (unsigned char *)nrec->data + sizeof(comp_stream_header);
max_compression_length = dcr->jcr->compress.deflate_buffer_size - sizeof(comp_stream_header);
break;
case STREAM_SPARSE_DATA:
data = (unsigned char *)nrec->data + OFFSET_FADDR_SIZE + sizeof(comp_stream_header);
max_compression_length = dcr->jcr->compress.deflate_buffer_size - OFFSET_FADDR_SIZE - sizeof(comp_stream_header);
break;
}
/*
* Compress the data using the configured compression algorithm.
*/
if (!compress_data(dcr->jcr, dcr->device->autodeflate_algorithm, rec->data, rec->data_len,
data, max_compression_length, &nrec->data_len)) {
bfuncs->free_record(nrec);
goto bail_out;
}
/*
* Map the streams.
*/
switch (rec->maskedStream) {
case STREAM_FILE_DATA:
nrec->Stream = STREAM_COMPRESSED_DATA;
nrec->maskedStream = STREAM_COMPRESSED_DATA;
break;
case STREAM_WIN32_DATA:
nrec->Stream = STREAM_WIN32_COMPRESSED_DATA;
nrec->maskedStream = STREAM_WIN32_COMPRESSED_DATA;
break;
case STREAM_SPARSE_DATA:
nrec->Stream = STREAM_SPARSE_COMPRESSED_DATA;
nrec->maskedStream = STREAM_SPARSE_COMPRESSED_DATA;
break;
default:
break;
}
/*
* Generate a compression header.
*/
ch.magic = dcr->device->autodeflate_algorithm;
ch.level = dcr->device->autodeflate_level;
ch.version = COMP_HEAD_VERSION;
ch.size = nrec->data_len;
switch (nrec->maskedStream) {
case STREAM_COMPRESSED_DATA:
case STREAM_WIN32_COMPRESSED_DATA:
ser_begin(nrec->data, sizeof(comp_stream_header));
ser_uint32(ch.magic);
ser_uint32(ch.size);
ser_uint16(ch.level);
ser_uint16(ch.version);
ser_end(nrec->data, sizeof(comp_stream_header));
nrec->data_len += sizeof(comp_stream_header);
break;
case STREAM_SPARSE_COMPRESSED_DATA:
/*
* Copy the sparse offset from the original.
*/
memcpy(nrec->data, rec->data, OFFSET_FADDR_SIZE);
ser_begin(nrec->data + OFFSET_FADDR_SIZE, sizeof(comp_stream_header));
ser_uint32(ch.magic);
ser_uint32(ch.size);
ser_uint16(ch.level);
ser_uint16(ch.version);
ser_end(nrec->data + OFFSET_FADDR_SIZE, sizeof(comp_stream_header));
nrec->data_len += OFFSET_FADDR_SIZE + sizeof(comp_stream_header);
break;
}
Dmsg4(400, "auto_deflate_record: From datastream %d to %d from original size %ld to %ld\n",
rec->maskedStream, nrec->maskedStream, rec->data_len, nrec->data_len);
/*
* If the input is just an intermediate value free it now.
*/
if (intermediate_value) {
bfuncs->free_record(dcr->after_rec);
}
dcr->after_rec = nrec;
retval = true;
bail_out:
return retval;
}
