QString MessagePart::subject() {
if (!hasHeader("Subject")) {
return QString();
}
const QString &subject = m_headers["Subject"];
// value: =?UTF-16LE?B?(base64(subject))?=
QStringList parts = subject.split('?');
if (parts.size() < 3) {
return subject;
}
const QString &charset = parts[1];
const QString &encoding = parts[2];
const QString &text = parts[3];
if (charset != "UTF-16LE") {
return subject;
}
if (encoding != "B") { // base64
return subject;
}
QTextCodec *codec = QTextCodec::codecForName( charset.toAscii() );
return m_text = codec->toUnicode( QByteArray::fromBase64( text.toAscii() ) );
}
bool seissol::checkpoint::mpio::Wavefield::validate(MPI_File file)
{
if (setHeaderView(file) != 0) {
logWarning() << "Could not set checkpoint header view";
return false;
}
int result = true;
if (rank() == 0 && hasHeader()) { // Only validate on compute nodes
// Check the header
MPI_File_read(file, header().data(), 1, headerType(), MPI_STATUS_IGNORE);
if (header().identifier() != identifier()) {
logWarning() << "Checkpoint identifier does match";
result = false;
} else if (header().value(m_partitionComp) != partitions()) {
logWarning() << "Number of partitions in checkpoint does not match";
result = false;
}
}
// Make sure everybody knows the result of the validation
MPI_Bcast(&result, 1, MPI_INT, 0, comm());
return result;
}
void HttpParser::parseHeader()
{
if (hasHeader() && !bHeaderParsed_) {
lHeaders_.Empty();
KeyValueLfBlob2List(sHeader_, lHeaders_);
{ // Request line
Elem* e = lHeaders_.First();
if (e) {
sMethod_ = e->getName();
sProtocol_ = e->getString();
sProtocol_.nextToken(" ", sUri_);
lHeaders_.Remove(e);
delete e;
e = 0;
}
}
{ // Body size
if (0) {
} else if (sMethod_ == "GET") {
nContentLength_ = 0;
} else if (sMethod_ == "HEAD") {
nContentLength_ = 0;
} else {
Elem* e = lHeaders_.FindByNameCase("content-length");
if (e) {
nContentLength_ = String::atoi(e->getString());
}
}
}
bHeaderParsed_ = 1;
}
}
bool HttpResponse::sendTemplate(TemplateFileStream* newTemplateInstance)
{
if (stream != NULL)
{
SYSTEM_ERROR("Stream already created");
delete stream;
stream = NULL;
}
stream = newTemplateInstance;
if (!newTemplateInstance->fileExist())
{
notFound();
delete stream;
stream = NULL;
return false;
}
if (!hasHeader("Content-Type"))
{
const char *mime = ContentType::fromFullFileName(newTemplateInstance->fileName());
if (mime != NULL)
setContentType(mime);
}
return true;
}
/**
* @brief Parse socket data.
* @param [in] s The socket from which to retrieve data.
*/
void HttpParser::parse(Socket s) {
std::string line;
line = s.readToDelim(lineTerminator);
parseRequestLine(line);
line = s.readToDelim(lineTerminator);
while(!line.empty()) {
m_headers.insert(parseHeader(line));
line = s.readToDelim(lineTerminator);
}
// Only PUT and POST requests have a body
if (getMethod() != "POST" && getMethod() != "PUT") {
return;
}
// We have now parsed up to and including the separator ... we are now at the point where we
// want to read the body. There are two stories here. The first is that we know the exact length
// of the body or we read until we can't read anymore.
if (hasHeader(HttpRequest::HTTP_HEADER_CONTENT_LENGTH)) {
std::string val = getHeader(HttpRequest::HTTP_HEADER_CONTENT_LENGTH);
int length = std::atoi(val.c_str());
uint8_t data[length];
s.receive_cpp(data, length, true);
m_body = std::string((char *)data, length);
} else {
uint8_t data[512];
int rc = s.receive_cpp(data, sizeof(data));
m_body = std::string((char *)data, rc);
}
ESP_LOGD(LOG_TAG, "Size of body: %d", m_body.length());
} // parse
void HttpData::setDocumentAndLength(StreamInterface* document) {
// TODO: Consider calling Rewind() here?
ASSERT(!hasHeader(HH_CONTENT_LENGTH, NULL));
ASSERT(!hasHeader(HH_TRANSFER_ENCODING, NULL));
ASSERT(document != NULL);
this->document.reset(document);
size_t content_length = 0;
if (this->document->GetAvailable(&content_length)) {
char buffer[32];
sprintfn(buffer, sizeof(buffer), "%d", content_length);
setHeader(HH_CONTENT_LENGTH, buffer);
}
else {
setHeader(HH_TRANSFER_ENCODING, "chunked");
}
}
bool ESP8266WebServer::authenticate(const char * username, const char * password){
if(hasHeader(AUTHORIZATION_HEADER)){
String authReq = header(AUTHORIZATION_HEADER);
if(authReq.startsWith("Basic")){
authReq = authReq.substring(6);
authReq.trim();
char toencodeLen = strlen(username)+strlen(password)+1;
char *toencode = new char[toencodeLen];
if(toencode == NULL){
authReq = String();
return false;
}
char *encoded = new char[base64_encode_expected_len(toencodeLen)+1];
if(encoded == NULL){
authReq = String();
delete[] toencode;
return false;
}
sprintf(toencode, "%s:%s", username, password);
if(base64_encode_chars(toencode, toencodeLen, encoded) > 0 && authReq.equals(encoded)){
authReq = String();
delete[] toencode;
delete[] encoded;
return true;
}
delete[] toencode;
delete[] encoded;
}
authReq = String();
}
return false;
}
bool HttpResponse::sendFile(String fileName, bool allowGzipFileCheck /* = true*/)
{
if (stream != NULL)
{
SYSTEM_ERROR("Stream already created");
delete stream;
stream = NULL;
}
String compressed = fileName + ".gz";
if (allowGzipFileCheck && fileExist(compressed))
{
debugf("found %s", compressed.c_str());
stream = new FileStream(compressed);
setHeader("Content-Encoding", "gzip");
}
else if (fileExist(fileName))
{
debugf("found %s", fileName.c_str());
stream = new FileStream(fileName);
}
else
{
notFound();
return false;
}
if (!hasHeader("Content-Type"))
{
const char *mime = ContentType::fromFullFileName(fileName);
if (mime != NULL)
setContentType(mime);
}
return true;
}
void HttpParser::parse(unsigned char* pData, size_t nLength)
{
sbData_.Append(pData, nLength);
findHeader();
if (hasHeader()) {
findBody();
}
}
void QtGroupBoxPropertyBrowserPrivate::slotUpdate()
{
QListIterator<WidgetItem *> itItem(m_recreateQueue);
while (itItem.hasNext())
{
WidgetItem *item = itItem.next();
WidgetItem *par = item->parent;
QWidget *w = 0;
QGridLayout *l = 0;
int oldRow = -1;
if (!par)
{
w = q_ptr;
l = m_mainLayout;
oldRow = m_children.indexOf(item);
}
else
{
w = par->groupBox;
l = par->layout;
oldRow = par->children.indexOf(item);
if (hasHeader(par))
oldRow += 2;
}
if (item->widget)
{
item->widget->setParent(w);
}
else if (item->widgetLabel)
{
item->widgetLabel->setParent(w);
}
else
{
item->widgetLabel = new QLabel(w);
item->widgetLabel->setSizePolicy(QSizePolicy(QSizePolicy::Ignored,
QSizePolicy::Fixed));
item->widgetLabel->setTextFormat(Qt::PlainText);
}
int span = 1;
if (item->widget)
l->addWidget(item->widget, oldRow, 1, 1, 1);
else if (item->widgetLabel)
l->addWidget(item->widgetLabel, oldRow, 1, 1, 1);
else
span = 2;
item->label = new QLabel(w);
item->label->setSizePolicy(QSizePolicy(QSizePolicy::Fixed,
QSizePolicy::Fixed));
l->addWidget(item->label, oldRow, 0, 1, span);
updateItem(item);
}
m_recreateQueue.clear();
}
QString MessagePart::boundary() {
if (hasHeader("Boundary")) {
return header("Boundary");
}
const QString &contentType = m_headers["Content-Type"];
return contentType.mid(contentType.indexOf("boundary=") + 9).trimmed();
}
bool HttpResponse::sendJsonObject(JsonObjectStream* newJsonStreamInstance)
{
if (stream != NULL)
{
SYSTEM_ERROR("Stream already created");
delete stream;
stream = NULL;
}
stream = newJsonStreamInstance;
if (!hasHeader("Content-Type"))
setContentType(ContentType::JSON);
}
bool HttpRequestData::getRelativeUri(std::string* host,
std::string* path) const
{
if (HV_CONNECT == verb)
return false;
Url<char> url(this->path);
if (url.valid()) {
host->assign(url.address());
path->assign(url.full_path());
return true;
}
if (!hasHeader(HH_HOST, host))
return false;
path->assign(this->path);
return true;
}
bool HttpRequestData::getAbsoluteUri(std::string* uri) const {
if (HV_CONNECT == verb)
return false;
Url<char> url(path);
if (url.valid()) {
uri->assign(path);
return true;
}
std::string host;
if (!hasHeader(HH_HOST, &host))
return false;
url.set_address(host);
url.set_full_path(path);
uri->assign(url.url());
return url.valid();
}
void HttpParser::findBody()
{
if (hasHeader() && !hasBody()) {
if (nContentLength_ > 0) {
if (sHeader_.bytes() + nContentLength_ <= sbData_.Length()) {
sbBody_.SetData(sbData_.Data() + sHeader_.bytes(), nContentLength_);
bHasBody_ = 1;
}
} else if (nContentLength_ == 0) {
bHasBody_ = 1;
} else {
if (bFinal_) {
sbBody_.SetData(sbData_.Data() + sHeader_.bytes(), sbData_.Length() - sHeader_.bytes());
bHasBody_ = 1;
}
}
}
}
void HttpParser::findHeader()
{
if (sbData_.Length() > 5 && !hasHeader()) {
unsigned char* p = sbData_.Data();
unsigned int nOffset = 0;
int bCR = 0;
int bStartOfLine = 0;
int bHeaderComplete = 0;
int bDone = 0;
while (nOffset < sbData_.Length() && !bDone) {
unsigned char c = p[nOffset];
if (c == '\r') {
nOffset++;
if (nOffset < sbData_.Length()) {
c = p[nOffset];
} else {
bDone = 1;
}
}
if (!bDone) {
if (c == '\n') {
if (bStartOfLine) {
bHeaderComplete = 1;
bDone = 1;
} else {
bStartOfLine = 1;
}
} else {
bStartOfLine = 0;
}
nOffset++;
}
}
if (bHeaderComplete) {
sHeader_.set((const char *) sbData_.Data(), nOffset);
bHasHeader_ = 1;
parseHeader();
}
}
}
void Glove::onReadyRead()
{
if (!mPort->bytesAvailable()) {
return;
}
mBytes = mPort->readAll();
if (mBytes.size() < (4 + 4 * GloveConsts::numberOfSensors)) {
return;
}
if (!hasHeader()) {
return;
}
getDataFromFlexSensors();
emit dataIsRead();
}
string Response::getData()
{
string body = getBody();
ostringstream data;
data << "HTTP/1.0 " << code << "\r\n";
if (!hasHeader("Content-Length")) {
ostringstream length;
length << body.size();
setHeader("Content-Length", length.str());
}
map<string, string>::iterator it;
for (it=headers.begin(); it!=headers.end(); it++) {
data << (*it).first << ": " << (*it).second << "\r\n";
}
data << "\r\n";
data << body;
return data.str();
}
/// Return true if the Packet Zone begins with either the middle or tail of another packet.
bool hasContinuedData() const {
return ( hasHeaderlessData() || (hasHeader() && getFirstHeaderIndex() > 0) );
}
std::string HttpParser::getHeader(const std::string& name) {
if (!hasHeader(name)) {
return "";
}
return m_headers.at(name);
}
void QtGroupBoxPropertyBrowserPrivate::propertyRemoved(QtBrowserItem *index)
{
WidgetItem *item = m_indexToItem.value(index);
m_indexToItem.remove(index);
m_itemToIndex.remove(item);
WidgetItem *parentItem = item->parent;
int row = -1;
if (parentItem)
{
row = parentItem->children.indexOf(item);
parentItem->children.removeAt(row);
if (hasHeader(parentItem))
row += 2;
}
else
{
row = m_children.indexOf(item);
m_children.removeAt(row);
}
if (item->widget)
delete item->widget;
if (item->label)
delete item->label;
if (item->widgetLabel)
delete item->widgetLabel;
if (item->groupBox)
delete item->groupBox;
if (!parentItem)
{
removeRow(m_mainLayout, row);
}
else if (parentItem->children.count() != 0)
{
removeRow(parentItem->layout, row);
}
else
{
WidgetItem *par = parentItem->parent;
// QWidget *w = 0;
QGridLayout *l = 0;
// int oldRow = -1;
if (!par)
{
// w = q_ptr;
l = m_mainLayout;
// oldRow = m_children.indexOf(parentItem);
m_children.indexOf(parentItem);
}
else
{
// w = par->groupBox;
l = par->layout;
// oldRow = par->children.indexOf(parentItem);
par->children.indexOf(parentItem);
/*if (hasHeader(par))
oldRow += 2;
*/
}
if (parentItem->widget)
{
parentItem->widget->hide();
parentItem->widget->setParent(0);
}
else if (parentItem->widgetLabel)
{
parentItem->widgetLabel->hide();
parentItem->widgetLabel->setParent(0);
}
else
{
// parentItem->widgetLabel = new QLabel(w);
}
l->removeWidget(parentItem->groupBox);
delete parentItem->groupBox;
parentItem->groupBox = 0;
parentItem->line = 0;
parentItem->layout = 0;
if (!m_recreateQueue.contains(parentItem))
m_recreateQueue.append(parentItem);
updateLater();
}
m_recreateQueue.removeAll(item);
delete item;
}
void QtGroupBoxPropertyBrowserPrivate::propertyInserted(QtBrowserItem *index,
QtBrowserItem *afterIndex)
{
WidgetItem *afterItem = m_indexToItem.value(afterIndex);
WidgetItem *parentItem = m_indexToItem.value(index->parent());
WidgetItem *newItem = new WidgetItem();
newItem->parent = parentItem;
QGridLayout *layout = 0;
QWidget *parentWidget = 0;
int row = -1;
if (!afterItem)
{
row = 0;
if (parentItem)
parentItem->children.insert(0, newItem);
else
m_children.insert(0, newItem);
}
else
{
if (parentItem)
{
row = parentItem->children.indexOf(afterItem) + 1;
parentItem->children.insert(row, newItem);
}
else
{
row = m_children.indexOf(afterItem) + 1;
m_children.insert(row, newItem);
}
}
if (parentItem && hasHeader(parentItem))
row += 2;
if (!parentItem)
{
layout = m_mainLayout;
parentWidget = q_ptr;
}
else
{
if (!parentItem->groupBox)
{
m_recreateQueue.removeAll(parentItem);
WidgetItem *par = parentItem->parent;
QWidget *w = 0;
QGridLayout *l = 0;
int oldRow = -1;
if (!par)
{
w = q_ptr;
l = m_mainLayout;
oldRow = m_children.indexOf(parentItem);
}
else
{
w = par->groupBox;
l = par->layout;
oldRow = par->children.indexOf(parentItem);
if (hasHeader(par))
oldRow += 2;
}
parentItem->groupBox = new QGroupBox(w);
parentItem->layout = new QGridLayout();
parentItem->groupBox->setLayout(parentItem->layout);
if (parentItem->label)
{
l->removeWidget(parentItem->label);
delete parentItem->label;
parentItem->label = 0;
}
if (parentItem->widget)
{
l->removeWidget(parentItem->widget);
parentItem->widget->setParent(parentItem->groupBox);
parentItem->layout->addWidget(parentItem->widget, 0, 0, 1, 2);
parentItem->line = new QFrame(parentItem->groupBox);
}
else if (parentItem->widgetLabel)
{
l->removeWidget(parentItem->widgetLabel);
delete parentItem->widgetLabel;
parentItem->widgetLabel = 0;
}
if (parentItem->line)
{
parentItem->line->setFrameShape(QFrame::HLine);
parentItem->line->setFrameShadow(QFrame::Sunken);
parentItem->layout->addWidget(parentItem->line, 1, 0, 1, 2);
}
l->addWidget(parentItem->groupBox, oldRow, 0, 1, 2);
updateItem(parentItem);
}
layout = parentItem->layout;
parentWidget = parentItem->groupBox;
}
newItem->label = new QLabel(parentWidget);
newItem->label->setSizePolicy(QSizePolicy(QSizePolicy::Fixed,
QSizePolicy::Fixed));
newItem->widget = createEditor(index->property(), parentWidget);
if (!newItem->widget)
{
newItem->widgetLabel = new QLabel(parentWidget);
newItem->widgetLabel->setSizePolicy(QSizePolicy(QSizePolicy::Ignored,
QSizePolicy::Fixed));
newItem->widgetLabel->setTextFormat(Qt::PlainText);
}
else
{
QObject::connect(newItem->widget, SIGNAL(destroyed()), q_ptr,
SLOT(slotEditorDestroyed()));
m_widgetToItem[newItem->widget] = newItem;
}
insertRow(layout, row);
int span = 1;
if (newItem->widget)
layout->addWidget(newItem->widget, row, 1);
else if (newItem->widgetLabel)
layout->addWidget(newItem->widgetLabel, row, 1);
else
span = 2;
layout->addWidget(newItem->label, row, 0, 1, span);
m_itemToIndex[newItem] = index;
m_indexToItem[index] = newItem;
updateItem(newItem);
}
/// Returns a pointer (to memory) of the first header in the Packet Zone.
/// @throw MissingField If there is no first header.
ACE_UINT8* ptrFirstHeader() const {
if ( ! hasHeader() ) {
throw MissingField(MissingField::msg("AOS M_PDU", "Packet Zone Header"));
}
return ptrPacketZone() + getFirstHeaderIndex();
}
int main(int argc, char* argv[])
{
try
{
COptionParser optParser(appliOption, appliName, appliUsageShort, appliUsageLong, authorName, authorMail);
optParser.PrintHeader(std::cout);
if (!optParser.ParseCommandLine(&argc, &argv, 2, false))
{
optParser.PrintError(std::cout);
optParser.PrintUsage(std::cout);
return -1;
}
bool headerCheck = !optParser.FindOption('n');
std::ifstream inFile;
inFile.open(argv[1],std::ios::in | std::ios::binary);
TOOLS_ASSERTMSG(inFile.good(),"Unable to open " << argv[1]);
std::ofstream outFile;
outFile.open(argv[2]);
TOOLS_ASSERTMSG(outFile.good(),"Unable to open " << argv[2]);
if (headerCheck)
{
if (hasHeader(inFile))
{
inFile.seekg(0x80,std::ios::beg);
}
}
unsigned char c;
c = (unsigned char)inFile.get();
while (!inFile.eof() && c!=0)
{
if (c == 0xff)
{
// Commentaire ligne
outFile << ";";
c = (unsigned char)inFile.get();
while (c != 0xd)
{
outFile << c;
c = (unsigned char)inFile.get();
}
outFile << std::endl;
}
else
{
if (c >= 0x80 && c!= 0x0d)
{
// Mnemonique sans label
// ENT
if (c == 0xc9)
outFile << ";";
outFile << "\t" << damsMnemonique[c-0x80] << "\t";
// DS ?,?
if (c == 0xc6)
{
c = (unsigned char)inFile.get();
// Fin de ligne
while (c != 0x0d)
{
if (c == ',')
{
while (c != 0x0d && c != 0xff)
c = (unsigned char)inFile.get();
}
if (c != 0x0d)
{
if (c == 0xff)
outFile << "\t;";
else
outFile << c;
c = (unsigned char)inFile.get();
}
}
}
else
{
c = (unsigned char)inFile.get();
// Fin de ligne
while (c != 0x0d)
{
if (c == 0xff)
outFile << "\t;";
else
outFile << c;
c = (unsigned char)inFile.get();
}
}
outFile << std::endl;
}
else
{
// Label
while (c < 0x80 && c != 0x0d)
{
outFile << c;
c = (unsigned char)inFile.get();
}
if (c != 0x0d)
{
// Mnemonique apres label
// ENT
if (c == 0xc9)
outFile << ";";
if (c != 0xff)
outFile << "\t" << damsMnemonique[c-0x80] << "\t";
else
outFile << "\t\t\t;";
// DS ?,?
if (c == 0xc6)
{
c = (unsigned char)inFile.get();
// Fin de ligne
while (c != 0x0d)
{
if (c == ',')
{
while (c != 0x0d && c != 0xff)
c = (unsigned char)inFile.get();
}
if (c != 0x0d)
{
if (c == 0xff)
outFile << "\t;";
else
outFile << c;
c = (unsigned char)inFile.get();
}
}
}
else
{
c = (unsigned char)inFile.get();
// Fin de ligne
while (c != 0x0d)
{
if (c == 0xff)
outFile << "\t;";
else
outFile << c;
c = (unsigned char)inFile.get();
}
}
outFile << std::endl;
}
else
{
outFile << std::endl;
}
}
}
if (!inFile.eof())
c = (unsigned char)inFile.get();
}
}
catch(tools::CException &e)
{
std::cerr << e << std::endl;
return -1;
}
return 0;
}
bool ESP8266WebServer::authenticate(const char * username, const char * password){
if(hasHeader(AUTHORIZATION_HEADER)){
String authReq = header(AUTHORIZATION_HEADER);
if(authReq.startsWith("Basic")){
authReq = authReq.substring(6);
authReq.trim();
char toencodeLen = strlen(username)+strlen(password)+1;
char *toencode = new char[toencodeLen + 1];
if(toencode == NULL){
authReq = String();
return false;
}
char *encoded = new char[base64_encode_expected_len(toencodeLen)+1];
if(encoded == NULL){
authReq = String();
delete[] toencode;
return false;
}
sprintf(toencode, "%s:%s", username, password);
if(base64_encode_chars(toencode, toencodeLen, encoded) > 0 && authReq.equalsConstantTime(encoded)) {
authReq = String();
delete[] toencode;
delete[] encoded;
return true;
}
delete[] toencode;
delete[] encoded;
}else if(authReq.startsWith("Digest")){
authReq = authReq.substring(7);
#ifdef DEBUG_ESP_HTTP_SERVER
DEBUG_OUTPUT.println(authReq);
#endif
String _username = _exractParam(authReq,"username=\"");
if((!_username.length())||_username!=String(username)){
authReq = String();
return false;
}
// extracting required parameters for RFC 2069 simpler Digest
String _realm = _exractParam(authReq,"realm=\"");
String _nonce = _exractParam(authReq,"nonce=\"");
String _uri = _exractParam(authReq,"uri=\"");
String _response = _exractParam(authReq,"response=\"");
String _opaque = _exractParam(authReq,"opaque=\"");
if((!_realm.length())||(!_nonce.length())||(!_uri.length())||(!_response.length())||(!_opaque.length())){
authReq = String();
return false;
}
if((_opaque!=_sopaque)||(_nonce!=_snonce)||(_realm!=_srealm)){
authReq = String();
return false;
}
// parameters for the RFC 2617 newer Digest
String _nc,_cnonce;
if(authReq.indexOf("qop=auth") != -1){
_nc = _exractParam(authReq,"nc=",',');
_cnonce = _exractParam(authReq,"cnonce=\"");
}
MD5Builder md5;
md5.begin();
md5.add(String(username)+":"+_realm+":"+String(password)); // md5 of the user:realm:user
md5.calculate();
String _H1 = md5.toString();
#ifdef DEBUG_ESP_HTTP_SERVER
DEBUG_OUTPUT.println("Hash of user:realm:pass="******"GET:"+_uri);
}else if(_currentMethod == HTTP_POST){
md5.add("POST:"+_uri);
}else if(_currentMethod == HTTP_PUT){
md5.add("PUT:"+_uri);
}else if(_currentMethod == HTTP_DELETE){
md5.add("DELETE:"+_uri);
}else{
md5.add("GET:"+_uri);
}
md5.calculate();
String _H2 = md5.toString();
#ifdef DEBUG_ESP_HTTP_SERVER
DEBUG_OUTPUT.println("Hash of GET:uri=" + _H2);
#endif
md5.begin();
if(authReq.indexOf("qop=auth") != -1){
md5.add(_H1+":"+_nonce+":"+_nc+":"+_cnonce+":auth:"+_H2);
}else{
md5.add(_H1+":"+_nonce+":"+_H2);
}
md5.calculate();
String _responsecheck = md5.toString();
#ifdef DEBUG_ESP_HTTP_SERVER
DEBUG_OUTPUT.println("The Proper response=" +_responsecheck);
#endif
if(_response==_responsecheck){
authReq = String();
return true;
}
}
authReq = String();
}
return false;
}
