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()); } }