bool client_request::write_header(std::ostream &os) {
std::string ka;
if (keep_alive) {
ka="keep-alive";
} else {
ka="close";
}
auto i=headers.find("connection");
if (i==headers.end()) {
headers.insert(std::make_pair("Connection", ka));
} else {
i->second.assign(ka);
}
if (!common::request::write_header(os)) return false;
return !os.eof() && !os.fail() && !os.bad();
}
static int docopy_noseek(std::istream &i, std::ostream &o)
{
char buf[BUFSIZ];
i.read(buf, sizeof(buf));
int x;
while ((x=i.gcount()) > 0)
{
o.write(buf, x);
i.read(buf, sizeof(buf));
}
if (o.bad() || i.bad())
return (EX_OSERR);
return (0);
}
bool client_request::write(std::ostream &os) {
// Set "content-length"
auto i=headers.find("content-length");
if (i==headers.end()) {
headers.insert(std::make_pair("Content-Length", boost::lexical_cast<std::string>(get_content_length())));
} else {
i->second.assign(boost::lexical_cast<std::string>(get_content_length()));
}
// Write header
if (!write_header(os)) return false;
// Write body
if (!raw_body_stream_.vector().empty()) {
os.write(&(raw_body_stream_.vector()[0]), raw_body_stream_.vector().size());
}
os.flush();
return !os.eof() && !os.fail() && !os.bad();
}
easyqrpng_error_t easyqrpng::save(std::ostream &output)
{
if (_impl->qrcode == NULL)
return setError(EASYQRPNGERR_NOT_ENCODED);
int width = _impl->qrcode->width;
int margin = _impl->margin;
int size = _impl->targetWidth / width;
if (size < 1)
size = 1;
const unsigned char colWhite[] = { 255, 255, 255 };
const unsigned char colBlack[] = { 0, 0, 0 };
CImg<unsigned char> cimage(width*size + margin*2, width*size + margin*2, 1, 3);
cimage.draw_rectangle(0, 0, cimage.width(), cimage.height(), colWhite);
unsigned char *p = _impl->qrcode->data;
for(int y=0; y<width; y++) {
for(int x=0; x<width; x++) {
const unsigned char *cl = (*p&1) ? &colBlack[0] : &colWhite[0];
cimage.draw_rectangle(margin + x*size, margin + y*size, margin + x*size+size, margin + y*size+size, cl);
p++;
}
}
// must convert to lodepng format
CImg<unsigned char> cimageinter = cimage.get_permute_axes("cxyz");
unsigned char* out;
size_t outsize;
unsigned error = lodepng_encode24(&out, &outsize, cimageinter.data(), cimage.width(), cimage.height());
if (error)
return setError(EASYQRPNGERR_ENCODEPNG_ERROR);
output.write(reinterpret_cast<const char*>(out), outsize);
if (output.bad())
return setError(EASYQRPNGERR_ENCODEPNG_ERROR);
return setError(EASYQRPNGERR_OK);
}
void MeshKernel::Write (std::ostream &rclOut) const
{
if (!rclOut || rclOut.bad())
return;
Base::OutputStream str(rclOut);
// Write a header with a "magic number" and a version
str << (uint32_t)0xA0B0C0D0;
str << (uint32_t)0x010000;
char szInfo[257]; // needs an additional byte for zero-termination
strcpy(szInfo, "MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-"
"MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-"
"MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-MESH-"
"MESH-MESH-MESH-\n");
rclOut.write(szInfo, 256);
// write the number of points and facets
str << (uint32_t)CountPoints() << (uint32_t)CountFacets();
// write the data
for (MeshPointArray::_TConstIterator it = _aclPointArray.begin(); it != _aclPointArray.end(); ++it) {
str << it->x << it->y << it->z;
}
for (MeshFacetArray::_TConstIterator it = _aclFacetArray.begin(); it != _aclFacetArray.end(); ++it) {
str << (uint32_t)it->_aulPoints[0]
<< (uint32_t)it->_aulPoints[1]
<< (uint32_t)it->_aulPoints[2];
str << (uint32_t)it->_aulNeighbours[0]
<< (uint32_t)it->_aulNeighbours[1]
<< (uint32_t)it->_aulNeighbours[2];
}
str << _clBoundBox.MinX << _clBoundBox.MaxX;
str << _clBoundBox.MinY << _clBoundBox.MaxY;
str << _clBoundBox.MinZ << _clBoundBox.MaxZ;
}
void PropertyReader::write(std::ostream& os, const std::string& message, const Properties& props) const
{
Properties::const_iterator it = props.begin(), end = props.end();
std::istringstream lineStream(message);
std::string line;
// print the comments taking in account the end of lines
while (std::getline(lineStream, line))
{
os << "#" << line << "\n";
}
for (; it != end; ++it)
{
// Write property on the stream
os << it->first << "=" << it->second << "\n";
}
if (os.bad())
throw PropertyStreamError();
}
//Rebuild PE image and write it to "out" ostream
//If strip_dos_header is true, DOS headers partially will be used for PE headers
//If change_size_of_headers == true, SizeOfHeaders will be recalculated automatically
//If save_bound_import == true, existing bound import directory will be saved correctly (because some compilers and bind.exe put it to PE headers)
void rebuild_pe(pe_base& pe, std::ostream& out, bool strip_dos_header, bool change_size_of_headers, bool save_bound_import)
{
if(out.bad())
throw pe_exception("Stream is bad", pe_exception::stream_is_bad);
if(save_bound_import && pe.has_bound_import())
{
if(pe.section_data_length_from_rva(pe.get_directory_rva(image_directory_entry_bound_import), pe.get_directory_rva(image_directory_entry_bound_import), section_data_raw, true)
< pe.get_directory_size(image_directory_entry_bound_import))
throw pe_exception("Incorrect bound import directory", pe_exception::incorrect_bound_import_directory);
}
//Change ostream state
out.exceptions(std::ios::goodbit);
out.clear();
uint32_t original_bound_import_rva = pe.has_bound_import() ? pe.get_directory_rva(image_directory_entry_bound_import) : 0;
if(original_bound_import_rva && original_bound_import_rva > pe.get_size_of_headers())
{
//No need to do anything with bound import directory
//if it is placed inside of any section, not headers
original_bound_import_rva = 0;
save_bound_import = false;
}
{
image_dos_header dos_header;
//Rebuild PE image headers
rebuild_pe(pe, dos_header, strip_dos_header, change_size_of_headers, save_bound_import);
//Write DOS header
out.write(reinterpret_cast<const char*>(&dos_header), strip_dos_header ? 8 * sizeof(uint16_t) : sizeof(image_dos_header));
}
//If we have stub overlay, write it too
{
const std::string& stub = pe.get_stub_overlay();
if(stub.size())
{
out.write(stub.data(), stub.size());
size_t aligned_size = pe_utils::align_up(stub.size(), sizeof(uint32_t));
//Align PE header, which is right after rich overlay
while(aligned_size > stub.size())
{
out.put('\0');
--aligned_size;
}
}
}
//Write NT headers
out.write(static_cast<const pe_base&>(pe).get_nt_headers_ptr(), pe.get_sizeof_nt_header()
- sizeof(image_data_directory) * (image_numberof_directory_entries - pe.get_number_of_rvas_and_sizes()));
//Write section headers
const section_list& sections = pe.get_image_sections();
for(section_list::const_iterator it = sections.begin(); it != sections.end(); ++it)
{
out.write(reinterpret_cast<const char*>(&(*it).get_raw_header()), sizeof(image_section_header));
}
//Write bound import data if requested
if(save_bound_import && pe.has_bound_import())
{
out.write(pe.section_data_from_rva(original_bound_import_rva, section_data_raw, true),
pe.get_directory_size(image_directory_entry_bound_import));
}
//Write section data finally
for(section_list::const_iterator it = sections.begin(); it != sections.end(); ++it)
{
const section& s = *it;
std::streamoff wpos = out.tellp();
//Fill unused overlay data between sections with null bytes
for(unsigned int i = 0; i < s.get_pointer_to_raw_data() - wpos; i++)
out.put(0);
//Write raw section data
out.write(s.get_raw_data().data(), s.get_size_of_raw_data());
}
}