#ifdef RCL_USE_XATTR

#ifdef RCL_USE_XATTR

#include "pxattr.h"

#include "pxattr.h"

#endif // RCL_USE_XATTR

#endif // RCL_USE_XATTR

static const string stxtplain("text/plain");

// The internal path element separator. This can't be the same as the rcldb 

// The internal path element separator. This can't be the same as the rcldb 

// file to ipath separator : "|"

// file to ipath separator : "|"

// We replace it with a control char if it comes out of a filter (ie:

// We replace it with a control char if it comes out of a filter (ie:

// rclzip or rclchm can do this). If you want the SOH control char

// rclzip or rclchm can do this). If you want the SOH control char

// inside an ipath, you're out of luck (and a bit weird).

// inside an ipath, you're out of luck (and a bit weird).

static const string isep(":");

static const char colon_repl = '\x01';

static string colon_hide(const string& in)

static string colon_hide(const string& in)

{

{

    string out;

    string out;

    for (string::const_iterator it = in.begin(); it != in.end(); it++) {

    for (string::const_iterator it = in.begin(); it != in.end(); it++) {

    out += *it == ':' ? colon_repl : *it;

    }

    }

    return out;

    return out;

}

}

static string colon_restore(const string& in)

static string colon_restore(const string& in)

{

{

    string out;

    string out;

    for (string::const_iterator it = in.begin(); it != in.end(); it++) {

    for (string::const_iterator it = in.begin(); it != in.end(); it++) {

    out += *it == colon_repl ? ':' : *it;

    }

    }

    return out;

    return out;

}

}

#ifdef RCL_USE_XATTR

#ifdef RCL_USE_XATTR

    string::size_type colon;

    string::size_type colon;

    LOGDEB(("FileInterner::getEnclosing(): url [%s] ipath [%s]\n", 

    LOGDEB(("FileInterner::getEnclosing(): url [%s] ipath [%s]\n", 

        url.c_str(), eipath.c_str()));

        url.c_str(), eipath.c_str()));

    if (eipath.empty())

    if (eipath.empty())

    return false;

    return false;

    if ((colon =  eipath.find_last_of(isep)) != string::npos) {

    eipath.erase(colon);

    eipath.erase(colon);

    } else {

    } else {

    eipath.erase();

    eipath.erase();

    }

    }

    make_udi(url_gpath(eurl), eipath, udi);

    make_udi(url_gpath(eurl), eipath, udi);

    m_forPreview = ((flags & FIF_forPreview) != 0);

    m_forPreview = ((flags & FIF_forPreview) != 0);

    // Initialize handler stack.

    // Initialize handler stack.

    m_handlers.reserve(MAXHANDLERS);

    m_handlers.reserve(MAXHANDLERS);

    for (unsigned int i = 0; i < MAXHANDLERS; i++)

    for (unsigned int i = 0; i < MAXHANDLERS; i++)

    m_tmpflgs[i] = false;

    m_tmpflgs[i] = false;

    m_targetMType = stxtplain;

}

}

// We used a single beagle cache object to access beagle data. We protect it 

// We used a single beagle cache object to access beagle data. We protect it 

// against multiple thread access.

// against multiple thread access.

FileInterner::FileInterner(const Rcl::Doc& idoc, RclConfig *cnf, 

FileInterner::FileInterner(const Rcl::Doc& idoc, RclConfig *cnf, 

                           TempDir& td, int flags)

                           TempDir& td, int flags)

    : m_tdir(td), m_ok(false), m_missingdatap(0)

    : m_tdir(td), m_ok(false), m_missingdatap(0)

{

{

            return;

            return;

        }

        }

        string udi = it->second;

        string udi = it->second;

    {

    {

        // Retrieve from our webcache (beagle data). The beagler

        // Retrieve from our webcache (beagle data). The beagler

        // object is created at the first call of this routine and

        // object is created at the first call of this routine and

        // deleted when the program exits.

        // deleted when the program exits.

        static BeagleQueueCache beagler(cnf);

        if (!beagler.getFromCache(udi, dotdoc, data)) {

        LOGINFO(("FileInterner:: failed fetch from Beagle cache for [%s]\n",

        LOGINFO(("FileInterner:: failed fetch from Beagle cache for [%s]\n",

             udi.c_str()));

             udi.c_str()));

        return;

        return;

        }

        }

    }

    }

}

}

// These defs are for the Dijon meta array. Rcl::Doc predefined field

// These defs are for the Dijon meta array. Rcl::Doc predefined field

// names are used where appropriate. In some cases, Rcl::Doc names are

// names are used where appropriate. In some cases, Rcl::Doc names are

// used inside the Dijon metadata (ex: origcharset)

// used inside the Dijon metadata (ex: origcharset)

static const string keyau("author");

static const string keycs("charset");

static const string keyct("content");

static const string keyds("description");

static const string keyfn("filename");

static const string keymd("modificationdate");

static const string keymt("mimetype");

static const string keytt("title");

bool FileInterner::dijontorcl(Rcl::Doc& doc)

bool FileInterner::dijontorcl(Rcl::Doc& doc)

{

{

    Dijon::Filter *df = m_handlers.back();

    Dijon::Filter *df = m_handlers.back();

    if (df == 0) {

    if (df == 0) {

    }

    }

    const map<string, string>& docdata = df->get_meta_data();

    const map<string, string>& docdata = df->get_meta_data();

    for (map<string,string>::const_iterator it = docdata.begin(); 

    for (map<string,string>::const_iterator it = docdata.begin(); 

     it != docdata.end(); it++) {

     it != docdata.end(); it++) {

    if (it->first == keyct) {

        doc.text = it->second;

        doc.text = it->second;

    } else if (it->first == keymd) {

        doc.dmtime = it->second;

        doc.dmtime = it->second;

    } else if (it->first == Rcl::Doc::keyoc) {

    } else if (it->first == Rcl::Doc::keyoc) {

        doc.origcharset = it->second;

        doc.origcharset = it->second;

    } else if (it->first == keymt || it->first == keycs) {

        // don't need/want these.

        // don't need/want these.

    } else {

    } else {

        doc.meta[it->first] = it->second;

        doc.meta[it->first] = it->second;

    }

    }

    }

    }

    if (doc.meta[Rcl::Doc::keyabs].empty() && !doc.meta[keyds].empty()) {

    doc.meta[Rcl::Doc::keyabs] = doc.meta[keyds];

    doc.meta.erase(keyds);

    }

    }

    return true;

    return true;

}

}

// Collect the ipath from the current path in the document tree.

// Collect the ipath from the current path in the document tree.

    const map<string, string>& docdata = (*hit)->get_meta_data();

    const map<string, string>& docdata = (*hit)->get_meta_data();

    if (getKeyValue(docdata, "ipath", ipathel)) {

    if (getKeyValue(docdata, "ipath", ipathel)) {

        if (!ipathel.empty()) {

        if (!ipathel.empty()) {

        // We have a non-empty ipath

        // We have a non-empty ipath

        hasipath = true;

        hasipath = true;

        getKeyValue(docdata, keymt, doc.mimetype);

        getKeyValue(docdata, keyfn, doc.utf8fn);

        }

        }

        doc.ipath += colon_hide(ipathel) + isep;

    } else {

    } else {

        doc.ipath += isep;

    }

    }

    getKeyValue(docdata, keyau, doc.meta[Rcl::Doc::keyau]);

    getKeyValue(docdata, keymd, doc.dmtime);

    }

    }

    // Trim empty tail elements in ipath.

    // Trim empty tail elements in ipath.

    if (hasipath) {

    if (hasipath) {

    LOGDEB2(("IPATH [%s]\n", doc.ipath.c_str()));

    LOGDEB2(("IPATH [%s]\n", doc.ipath.c_str()));

    string::size_type sit = doc.ipath.find_last_not_of(isep);

    if (sit == string::npos)

    if (sit == string::npos)

        doc.ipath.erase();

        doc.ipath.erase();

    else if (sit < doc.ipath.length() -1)

    else if (sit < doc.ipath.length() -1)

        doc.ipath.erase(sit+1);

        doc.ipath.erase(sit+1);

    } else {

    } else {

// and possibly add a filter/handler to the stack

// and possibly add a filter/handler to the stack

int FileInterner::addHandler()

int FileInterner::addHandler()

{

{

    const map<string, string>& docdata = m_handlers.back()->get_meta_data();

    const map<string, string>& docdata = m_handlers.back()->get_meta_data();

    string charset, mimetype;

    string charset, mimetype;

    getKeyValue(docdata, keycs, charset);

    getKeyValue(docdata, keymt, mimetype);

    LOGDEB(("FileInterner::addHandler: next_doc is %s\n", mimetype.c_str()));

    LOGDEB(("FileInterner::addHandler: next_doc is %s\n", mimetype.c_str()));

    // If we find a document of the target type (text/plain in

    // If we find a document of the target type (text/plain in

    // general), we're done decoding. If we hit text/plain, we're done

    // general), we're done decoding. If we hit text/plain, we're done

    // in any case

    // in any case

    if (!stringicmp(mimetype, m_targetMType) || 

    if (!stringicmp(mimetype, m_targetMType) || 

    !stringicmp(mimetype, stxtplain)) {

    m_reachedMType = mimetype;

    m_reachedMType = mimetype;

    LOGDEB1(("FileInterner::addHandler: target reached\n"));

    LOGDEB1(("FileInterner::addHandler: target reached\n"));

    return ADD_BREAK;

    return ADD_BREAK;

    }

    }

    // copying the text, which may be big.

    // copying the text, which may be big.

    string ns;

    string ns;

    const string *txt = &ns;

    const string *txt = &ns;

    {

    {

    map<string,string>::const_iterator it;

    map<string,string>::const_iterator it;

    it = docdata.find(keyct);

    if (it != docdata.end())

    if (it != docdata.end())

        txt = &it->second;

        txt = &it->second;

    }

    }

    bool setres = false;

    bool setres = false;

    if (newflt->is_data_input_ok(Dijon::Filter::DOCUMENT_STRING)) {

    if (newflt->is_data_input_ok(Dijon::Filter::DOCUMENT_STRING)) {

    // when they're pushed on the stack

    // when they're pushed on the stack

    vector<string> vipath;

    vector<string> vipath;

    int vipathidx = 0;

    int vipathidx = 0;

    if (!ipath.empty()) {

    if (!ipath.empty()) {

    vector<string> lipath;

    vector<string> lipath;

    stringToTokens(ipath, lipath, isep, true);

    for (vector<string>::iterator it = lipath.begin();

    for (vector<string>::iterator it = lipath.begin();

         it != lipath.end(); it++) {

         it != lipath.end(); it++) {

        *it = colon_restore(*it);

        *it = colon_restore(*it);

    }

    }

    vipath.insert(vipath.begin(), lipath.begin(), lipath.end());

    vipath.insert(vipath.begin(), lipath.begin(), lipath.end());