/**
* Handle a PDU
* @pre m_pdu_size bytes in the buffer
*/
void IncomingStreamTransport::HandlePDU() {
OLA_DEBUG << "Got PDU, data length is " << DataLength() << ", expected " <<
m_pdu_size;
if (DataLength() != m_pdu_size) {
OLA_WARN << "PDU size doesn't match the available data";
m_stream_valid = false;
return;
}
HeaderSet header_set;
header_set.SetTransportHeader(m_transport_header);
unsigned int data_consumed = m_inflator->InflatePDUBlock(
&header_set,
m_buffer_start,
m_pdu_size);
OLA_DEBUG << "inflator consumed " << data_consumed << " bytes";
if (m_pdu_size != data_consumed) {
OLA_WARN << "PDU inflation size mismatch, " << m_pdu_size << " != "
<< data_consumed;
m_stream_valid = false;
return;
}
m_consumed_block_size += data_consumed;
if (m_consumed_block_size == m_block_size) {
// all PDUs in this block have been processed
EnterWaitingForPreamble();
} else {
EnterWaitingForPDU();
}
}
OpaqueVarbind::OpaqueVarbind(unsigned char* &pduPart)
:Varbind(pduPart, SNMPOPAQUE, "Opaque"),
mData(NULL)
{
mData = new unsigned char [DataLength()];
memcpy(mData, pduPart, DataLength());
pduPart += DataLength();
}
void
StructuredCloneData::WriteIPCParams(IPC::Message* aMsg) const
{
WriteParam(aMsg, DataLength());
if (DataLength()) {
// Structured clone data must be 64-bit aligned.
aMsg->WriteBytes(Data(), DataLength(), sizeof(uint64_t));
}
}
bool
BKey::operator==(const BKey& other) const
{
return Type() == other.Type()
&& DataLength() == other.DataLength()
&& Purpose() == other.Purpose()
&& fOwner == other.fOwner
&& fIdentifier == other.fIdentifier
&& fSecondaryIdentifier == other.fSecondaryIdentifier
&& memcmp(Data(), other.Data(), DataLength()) == 0;
}
TBool HPingHeader::SetHeader(TUint aOffset)
//
// Set the header from an Icmp reply
//
{
const TUint8* buffData;
// Check size
if(DataLength() < (TInt)KIcmpHeaderSize)
{
return EFalse;
}
buffData = iData->Des().Ptr();
if(!buffData)
{
return EFalse;
}
// Fill TInet6HeaderICMP_Echo from the buffer
for(int k=0;k<(TInt)KIcmpHeaderSize;k++)
{
i[k] = *(buffData + k + aOffset);
}
return ETrue;
}
/**
* Handle the Preamble data.
* @pre 20 bytes in the buffer
*/
void IncomingStreamTransport::HandlePreamble() {
OLA_DEBUG << "in handle preamble, data len is " << DataLength();
if (memcmp(m_buffer_start, ACN_HEADER, ACN_HEADER_SIZE) != 0) {
ola::FormatData(&std::cout, m_buffer_start, ACN_HEADER_SIZE);
ola::FormatData(&std::cout, ACN_HEADER, ACN_HEADER_SIZE);
OLA_WARN << "bad ACN header";
m_stream_valid = false;
return;
}
// read the PDU block length
memcpy(reinterpret_cast<void*>(&m_block_size),
m_buffer_start + ACN_HEADER_SIZE,
sizeof(m_block_size));
m_block_size = ola::network::NetworkToHost(m_block_size);
OLA_DEBUG << "pdu block size is " << m_block_size;
if (m_block_size) {
m_consumed_block_size = 0;
EnterWaitingForPDU();
} else {
EnterWaitingForPreamble();
}
}
OpaqueVarbind::OpaqueVarbind(int value)
:Varbind(SNMPOPAQUE, "Opaque"),
mData(NULL)
{
DataLength((unsigned short)((value / 255) + 1));
mData = new unsigned char [sizeof(int)];
*mData = value;
}
DistillerStatus gjpg_passthrough(DistillerInput *din, DistillerOutput *dout)
{
strcpy(dout->mimeType, din->mimeType);
SetDataLength(dout,DataLength(din));
SetData(dout, DataPtr(din));
DataNeedsFree(dout,gm_False);
return distOk;
}
DistillerStatus
ComputeDistillationCost(Argument *args, int numArgs,
DistillerInput *din,
DistillationCost *cost)
{
cost->estimatedTime_ms = DataLength(din);
return distOk;
}
OpaqueVarbind::OpaqueVarbind(unsigned short value)
:Varbind(SNMPOPAQUE, "Opaque"),
mData(NULL)
{
DataLength((unsigned short)((value / 255) + 1));
mData = new unsigned char [sizeof(unsigned short)];
memcpy(mData, &value, sizeof(unsigned short));
}
/**
* Handle the PDU Flag data, this allows us to figure out how many bytes we
* need to read the length.
* @pre 1 byte in the buffer
*/
void IncomingStreamTransport::HandlePDUFlags() {
OLA_DEBUG << "Reading PDU flags, data size is " << DataLength();
m_pdu_length_size = (*m_buffer_start & BaseInflator::LFLAG_MASK) ?
THREE_BYTES : TWO_BYTES;
m_outstanding_data += static_cast<unsigned int>(m_pdu_length_size) - 1;
OLA_DEBUG << "PDU length size is " << static_cast<int>(m_pdu_length_size) <<
" bytes";
m_state = WAITING_FOR_PDU_LENGTH;
}
unsigned char*
OpaqueVarbind::Data()
{
unsigned int len = DataLength();
unsigned int lenLen = (len / 129) + 1;
unsigned char* data = new unsigned char [len + lenLen + 1];
unsigned char* retVal = data;
Build(data);
return retVal;
}
std::vector<BYTE> kjm::eventlog_record::Data() {
std::vector<BYTE> data( DataLength() );
for ( int i = 0; i < data.size(); i++) {
data.at( i ) = *(((unsigned char *)getRaw()) + DataOffset() + i);
}
return data;
}
void
OpaqueVarbind::Build(unsigned char*& pdu)
{
unsigned int len = DataLength();
unsigned int lenLen = (len / 129) + 1;
pdu[0] = SNMPOPAQUE;
unsigned char* lPdu = pdu;
lPdu++;
encodeLength(lPdu, (long)len);
memcpy(&pdu[lenLen + 1], mData, len); // the tag too
}
TBool HPingHeader::VerifyNonEcho(TInt aId)
//
// Verify header which is not echo reply
//
{
// Fill TInet6HeaderICMP_Echo from packet data
TBool ret = SetHeader();
// Look at IP version
if(ret && iIPVersion == KAfInet) // IP4
{
switch(Type())
{
case KIPv4PingTypeUnreachable:
case KIPv4PingTypeSourceQuench:
case KIPv4PingTypeRedirect:
case KIPv4PingTypeTimeExceeded:
case KIPv4PingTypeBadParameter:
break;
default:
ret = EFalse;
}
if(ret && (DataLength() < (TInt)KIcmpHeaderSize))
{
ret = EFalse;
}
if(ret)
{
ret = SetHeader(KIcmpHeaderSize + KMinIpHeaderSize);
if(ret && (Type() != KIPv4PingTypeEchoRequest || Identifier() != aId))
{
ret = EFalse;
}
}
}
else
{ // IP6
switch(Type())
{
case KIPv6PingTypeUnreachable:
case KIPv6PingTypePacketTooBig:
case KIPv6PingTypeTimeExeeded:
case KIPv6PingTypeParamProblem:
break;
default:
ret = EFalse;
}
}
return ret;
}
void
StructuredCloneData::Read(JSContext* aCx,
JS::MutableHandle<JS::Value> aValue,
ErrorResult &aRv)
{
MOZ_ASSERT(Data());
nsIGlobalObject *global = xpc::NativeGlobal(JS::CurrentGlobalOrNull(aCx));
MOZ_ASSERT(global);
ReadFromBuffer(global, aCx, Data(), DataLength(), aValue, aRv);
}
/**
* Read data until we reach the number of bytes we required or there is no more
* data to be read
*/
void IncomingStreamTransport::ReadRequiredData() {
if (m_outstanding_data == 0)
return;
if (m_outstanding_data > FreeSpace())
IncreaseBufferSize(DataLength() + m_outstanding_data);
unsigned int data_read;
int ok = m_descriptor->Receive(m_data_end,
m_outstanding_data,
data_read);
if (ok != 0)
OLA_WARN << "tcp rx failed";
OLA_DEBUG << "read " << data_read;
m_data_end += data_read;
m_outstanding_data -= data_read;
}
const char*
OpaqueVarbind::Printable()
{
if (mPrintable == NULL)
{
unsigned short len = DataLength();
mPrintable = new char [len + 1];
for (unsigned short i = 0; i < len; i++)
{
if (isprint(mData[i]))
mPrintable[i] = mData[i];
else
mPrintable[i] = ' ';
}
mPrintable[len] = '\0';
}
return mPrintable;
}
/**
* Grow the rx buffer to the new size.
*/
void IncomingStreamTransport::IncreaseBufferSize(unsigned int new_size) {
if (new_size <= BufferSize())
return;
new_size = std::max(new_size, INITIAL_SIZE);
unsigned int data_length = DataLength();
if (!m_buffer_start)
data_length = 0;
// allocate new buffer and copy the data over
uint8_t *buffer = new uint8_t[new_size];
if (m_buffer_start) {
if (data_length > 0)
// this moves the data to the start of the buffer if it wasn't already
memcpy(buffer, m_buffer_start, data_length);
delete[] m_buffer_start;
}
m_buffer_start = buffer;
m_buffer_end = buffer + new_size;
m_data_end = buffer + data_length;
}
void
OpaqueVarbind::Value(char* value, unsigned int length)
{
DataLength(length);
memcpy(mData, value, length);
}
int
main(int argc, char *argv[])
{
DistillerStatus st;
UINT32 len;
int i;
char nextfile[MAX_FILENAME];
char logFile[MAX_FILENAME];
char *timeStr;
TestRun runs[MAX_TESTRUNS];
FILE *f;
time_t t;
int numRuns;
int repeatCount;
DistillerInput in;
DistillerOutput out;
C_DistillerType distType;
sprintf(distType.string, "test " INPUT_MIME_TYPE);
if (argc < 3) {
usage();
exit(1);
}
if (!(numRuns = readInputFile(argv[1],runs))) {
fprintf(stderr, "Error reading input file %s.\n", argv[1]);
exit(1);
}
repeatCount = atoi(argv[2]);
if (repeatCount <=0) {
fprintf(stderr, "Invaild count value.\n");
exit(1);
}
if ((st = DistillerInit(distType, 0, NULL)) != distOk) {
fprintf(stderr, "DistillerInit failed: error %d\n", (int)st);
exit(1);
}
sprintf(logFile,"harness.log");
t = time(NULL);
timeStr = ctime(&t);
printf("%s\n",logFile);
if ((f = fopen(logFile, "a")) == NULL) {
fprintf(stderr, "Can't open log file %s\n", logFile);
return 0;
}
SetMimeType(&in, INPUT_MIME_TYPE);
for (i=0;i<numRuns;i++) {
int fd;
int count;
int ii;
fprintf(stdout,"Test run for case %s:\n",runs[i].inputFileName);
fprintf(f,"Test run for case %s:\n",runs[i].inputFileName);
printArguments(f,*(runs[i].argList));
fd = open(runs[i].inputFileName, O_RDONLY);
if (fd == -1) {
fprintf(stderr, "Can't read %s, skipping\n", runs[i].inputFileName);
fprintf(f, "Can't read %s, skipping\n", runs[i].inputFileName);
continue;
}
for (len = 0;
(count = read(fd, (void*)(buf+len), (sizeof(buf)-len))) > 0;
len += count)
;
fprintf(stderr, "Read %lu bytes from %s\n", len, runs[i].inputFileName);
fprintf(f, "Read %lu bytes from %s\n", len, runs[i].inputFileName);
SetData(&in, (void *)buf);
SetDataLength(&in, len);
SetMetadata(&in, NULL);
SetMetadataLength(&in, 0);
for (ii= 0; ii<repeatCount; ii++) {
fprintf(stderr,"Calling distiller main\n");
fprintf(f,"Calling distiller main\n");
/* Distiller status */
st = DistillerMain(runs[i].argList->arg,runs[i].argList->nargs,&in,&out);
if (st != distOk) {
fprintf(stderr, "DistillerMain failed: error %d\n", (int)st);
fprintf(f, "DistillerMain failed: error %d\n", (int)st);
}
close(fd);
strcpy(nextfile,runs[i].inputFileName);
strcat(nextfile, ".OUT");
fd = open(nextfile, O_CREAT | O_WRONLY | O_TRUNC, 0666);
if (fd == -1) {
fprintf(stderr, "Can't write %s, using stdout\n", nextfile);
fprintf(f, "Can't write %s, using stdout\n", nextfile);
fd = fileno(stdout);
}
len = write(fd, (const void *)DataPtr(&out), (size_t)(DataLength(&out)));
if (fd != fileno(stdout))
close(fd);
fprintf(stderr, "Wrote %lu of %lu bytes to %s\n", len, DataLength(&out), nextfile);
fprintf(f, "Wrote %lu of %lu bytes to %s\n", len, DataLength(&out), nextfile);
if (out.data.freeMe == gm_True)
DistillerFree(DataPtr(&out));
if (out.metadata.freeMe == gm_True)
DistillerFree(MetadataPtr(&out));
}
}
fclose(f);
return(1);
}
int
main(int argc, char *argv[])
{
DistillerStatus st;
UINT32 len;
Argument args[12];
int nargs = 0;
int i;
char *k;
FILE *f;
char nextfile[255];
DistillerInput in;
DistillerOutput out;
C_DistillerType distType;
sprintf(distType.string, "test " INPUT_MIME_TYPE);
if ((argc < 2) || (argc >= 2 && strncmp(argv[1], "-h", 2) == 0)) {
usage();
exit(1);
}
if ((f = fopen(argv[1], "r")) == NULL) {
fprintf(stderr, "Can't open input file %s\n", argv[1]);
exit(1);
}
for (i=2; i<argc-1; i += 2, nargs++) {
SET_ARG_ID(args[nargs], strtoul(&argv[i][1], (char**)NULL, 0));
switch (argv[i][0]) {
case 'i':
SET_ARG_INT(args[nargs], strtol(argv[i+1], (char**)NULL, 0));
fprintf(stderr, "Arg id %lu is %ld\n", ARG_ID(args[nargs]),
ARG_INT(args[nargs]));
break;
case 'f':
SET_ARG_DOUBLE(args[nargs], strtod(argv[i+1], (char**)NULL));
fprintf(stderr, "Arg id %lu is %f\n", ARG_ID(args[nargs]),
(float)ARG_DOUBLE(args[nargs]));
break;
case 's':
default:
SET_ARG_STRING(args[nargs], argv[i+1]);
fprintf(stderr, "Arg id %lu is \"%s\"\n", ARG_ID(args[nargs]),
ARG_STRING(args[nargs]));
}
}
if ((st = DistillerInit(distType, 0, NULL)) != distOk) {
fprintf(stderr, "DistillerInit failed: error %d\n", (int)st);
exit(1);
}
SetMimeType(&in, INPUT_MIME_TYPE);
while (fgets(nextfile, 254, f) != NULL) {
char nextfile2[255];
int fd;
int count;
int ii;
nextfile[strlen(nextfile)-1] = 0;
fd = open(nextfile, O_RDONLY);
if (fd == -1) {
fprintf(stderr, "Can't read %s, skipping\n", nextfile);
continue;
}
for (len = 0;
(count = read(fd, (void*)(buf+len), (sizeof(buf)-len))) > 0;
len += count)
;
fprintf(stderr, "Read %lu bytes from %s\n", len, nextfile);
SetData(&in, (void *)buf);
SetDataLength(&in, len);
SetMetadata(&in, NULL);
SetMetadataLength(&in, 0);
for (ii= 0; ii<REPEAT_COUNT; ii++) {
fprintf(stderr,"Calling distiller main\n");
st = DistillerMain(args,nargs,&in,&out);
if (st != distOk) {
fprintf(stderr, "DistillerMain failed: error %d\n", (int)st);
}
close(fd);
strcpy(nextfile2, argv[argc-1]);
if (nextfile2[strlen(nextfile2)-1] != '/')
strcat(nextfile2,"/");
k = strrchr(nextfile, '/');
if (k)
strcat(nextfile2, k+1);
else
strcat(nextfile2, nextfile);
strcat(nextfile2, ".OUT");
fd = open(nextfile2, O_CREAT | O_WRONLY | O_TRUNC, 0666);
if (fd == -1) {
fprintf(stderr, "Can't write %s, using stdout\n", nextfile2);
fd = fileno(stdout);
}
len = write(fd, (const void *)DataPtr(&out), (size_t)(DataLength(&out)));
if (fd != fileno(stdout))
close(fd);
fprintf(stderr, "Wrote %lu of %lu bytes to %s\n", len, DataLength(&out), nextfile2);
if (out.data.freeMe == gm_True)
DistillerFree(DataPtr(&out));
if (out.metadata.freeMe == gm_True)
DistillerFree(MetadataPtr(&out));
}
}
return(1);
}
DistillerStatus
DistillerMain(Argument *args, int nargs,
DistillerInput *din,
DistillerOutput *dout)
{
JSAMPROW handoff = NULL;
JDIMENSION handoff_height, handoff_width, num_scanlines;
int max_x=-1, max_y=-1, min_x=-1, min_y=-1, qual=55, i;
int expert=0, resize=0, quality=3, nodistill=0, ismap=0;
double scale = 0.5;
cjpeg_source_ptr src_mgr;
void *phase1_data;
INT32 phase1_length;
int fin_denom, fin_qual;
DistillerStatus result = distBadInput;
SetData(dout, NULL);
bailout_now = 0;
if ( (setjmp(jumpbuffer) != 0) ) {
/*
* fatal error occurred, so return immediately.
*/
MonitorClientSend(monID, "Distiller Errors",
"Resetting distiller...\n", "Log");
DistillerExit();
DistillerInit(dType, 0, NULL);
if (DataPtr(dout) != NULL)
DataNeedsFree(dout,gm_True);
else
DataNeedsFree(dout,gm_False);
return distFatalError;
}
/*
* parse distillation arguments. set default values for some
* things, then override them if args are specified. Default will
* be to scale each axis by 0.5, turn quality down to 55%.
*/
for (i=0; i<nargs; i++) {
INT32 argval = ARG_INT(args[i]);
switch(ARG_ID(args[i])) {
case GJPG_MAX_X:
max_x = (int) argval;
break;
case GJPG_MAX_Y:
max_y = (int) argval;
break;
case GJPG_MIN_X:
min_x = (int) argval;
break;
case GJPG_MIN_Y:
min_y = (int) argval;
break;
case GJPG_SCALE:
scale = (double) ARG_DOUBLE(args[i]);
break;
case GJPG_QUAL:
qual = (int) argval;
break;
case FRONT_RESIZE:
resize = (int) argval;
break;
case FRONT_NO_DISTILL:
nodistill = (int) argval;
break;
case FRONT_QUALITY:
if (argval >= 1 && argval <= 5)
quality = (int) argval;
break;
case FRONT_EXPERT:
expert = (int) argval;
break;
case FRONT_ISMAP:
ismap = (int) argval;
break;
default:
break;
}
}
if (nodistill) {
return gjpg_passthrough(din, dout);
}
/* First pass through, we're just going to convert the GIF to JPEG */
phase1_data = NULL;
phase1_length = 0;
dstinfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&dstinfo);
src_mgr = jinit_read_gif(&dstinfo, (JOCTET *) DataPtr(din),
(INT32) DataLength(din));
(*src_mgr->start_input)(&dstinfo, src_mgr);
jpeg_default_colorspace(&dstinfo);
jpeg_mem_dest(&dstinfo, (void **) &phase1_data, (UINT32 *) &phase1_length);
jpeg_start_compress(&dstinfo, TRUE);
while (dstinfo.next_scanline < dstinfo.image_height) {
num_scanlines = (*src_mgr->get_pixel_rows)(&dstinfo, src_mgr);
jpeg_write_scanlines(&dstinfo, src_mgr->buffer, num_scanlines);
}
(*src_mgr->finish_input)(&dstinfo, src_mgr);
jpeg_finish_compress(&dstinfo);
/* early bailout because of animated or transparent gif? */
if (bailout_now
&& DataLength(din) <= bailout_thresh[quality]) {
result = distBadInput;
goto JPGMUNGE_RETURN;
}
/* Now we're into the second pass. Let's do our JPEG->JPEG
* distillation. We need to compute the denominator and the quality
* knob setting. */
if (expert) {
/* Do expert-like things here. Need to work out still. */
fin_qual = qual;
fin_denom = compute_scale_denom(max_x, max_y, min_x, min_y,
srcinfo.image_width,
srcinfo.image_height, scale);
} else {
/* We're in beginner mode. Life is easier. */
if (ismap) {
fin_qual = ismap_qual[quality-1];
fin_denom = ismap_denom[quality-1];
} else if (resize) {
fin_qual = noscale_qual[quality-1];
fin_denom = noscale_denom[quality-1];
} else {
fin_qual = norm_qual[quality-1];
fin_denom = norm_denom[quality-1];
}
}
/* Prep the input decompressor */
jpeg_mem_src(&srcinfo, phase1_data, phase1_length);
jpeg_read_header(&srcinfo, TRUE);
srcinfo.scale_num = 1;
srcinfo.scale_denom = fin_denom;
srcinfo.dither_mode = JDITHER_ORDERED;
srcinfo.dct_method = JDCT_FASTEST;
jpeg_start_decompress(&srcinfo);
/* Prep the output compressor */
SetDataLength(dout,0);
SetData(dout, NULL);
sprintf(dout->mimeType, "image/jpeg");
jpeg_mem_dest(&dstinfo, (void **) &(DataPtr(dout)),
(UINT32 *) &(DataLength(dout)));
dstinfo.image_width = srcinfo.output_width;
dstinfo.image_height = srcinfo.output_height;
dstinfo.input_components = srcinfo.output_components;
dstinfo.in_color_space = srcinfo.out_color_space;
jpeg_set_defaults(&dstinfo);
jpeg_set_quality(&dstinfo, fin_qual, TRUE);
jpeg_start_compress(&dstinfo, TRUE);
handoff_height = (JDIMENSION) 1;
handoff_width =
srcinfo.output_width*sizeof(JSAMPLE)*srcinfo.output_components;
handoff = (JSAMPROW) malloc(handoff_width);
/* We're going to need some buffer space to hand off data
from the decompressor to the compressor. */
while (srcinfo.output_scanline < srcinfo.output_height) {
num_scanlines = jpeg_read_scanlines(&srcinfo, &handoff, handoff_height);
jpeg_write_scanlines(&dstinfo, &handoff, num_scanlines);
}
jpeg_finish_decompress(&srcinfo);
jpeg_finish_compress(&dstinfo);
result = distOk;
JPGMUNGE_RETURN:
if (handoff)
free(handoff);
DataNeedsFree(dout,gm_True);
if (phase1_data)
free(phase1_data);
if (DataLength(dout) > DataLength(din)) {
SetDataLength(dout, DataLength(din));
memcpy(DataPtr(dout), DataPtr(din), DataLength(din));
sprintf(dout->mimeType, "image/gif");
}
DEBUG("finished processing\n");
return result;
}
void
OpaqueVarbind::Value(char value)
{
DataLength(1);
*mData = value;
}
void
OpaqueVarbind::Value(long value)
{
DataLength((unsigned short)(value / 255) + 1);
}
void
OpaqueVarbind::Value(short value)
{
DataLength((unsigned short)((value / 255) + 1));
}
