yum -y install automake autoconf libtool
mkdir -p /opt/packages
cd /opt/packages
wget http://www.measurement-factory.com/tmp/ecap/ecap_adapter_sample-0.2.0.tar.gz
wget http://www.measurement-factory.com/tmp/ecap/libecap-0.2.0.tar.gz
tar -zxf libecap-0.2.0.tar.gz
cd libecap-0.2.0
./configure
make
make install

wget http://www.squid-cache.org/Versions/v3/3.3/squid-3.3.3.tar.bz2
tar -xf squid-3.3.3.tar.bz2
cd squid-3.3.3
./configure --enable-http-violations --enable-ltdl-convenience --enable-icap-client --enable-ecap --prefix=/usr/local/squid PKG_CONFIG_PATH=/usr/local/lib/pkgconfig
make
make install

tar -zxf ecap_adapter_sample-0.2.0.tar.gz
mv ecap_adapter_sample-0.2.0 ecap_adapter_bbkanba
cd ecap_adapter_bbkanba/src
cp adapter_modifying.cc adapter_bbkanba.cc
sed -i -e 's/sample.h/bbkanba.h/' adapter_bbkanba.cc
sed -i -e '/.*\/config.h.*/d' adapter_bbkanba.cc
sed -i -e 's/.*ecap:\/\/.*/return "ecap:\/\/bbkanba.com\/bbkanba";/' adapter_bbkanba.cc
cat > Makefile.am <<ALLEND
EXTRA_DIST = \
    adapter_bbkanba.cc   
     
lib_LTLIBRARIES = \
    ecap_adapter_bbkanba.la
 
noinst_HEADERS = \
    bbkanba.h \
    Debugger.h \
    \
    autoconf.h 
 
ecap_adapter_bbkanba_la_SOURCES = adapter_bbkanba.cc \
                                 Debugger.cc 
             
ecap_adapter_bbkanba_la_CPPFLAGS = \$(LIBECAP_CFLAGS) 
ecap_adapter_bbkanba_la_LDFLAGS = -module -avoid-version \$(libecap_LIBS)
ecap_adapter_bbkanba_la_LIBADD= \$(LIBECAP_LIBS)  -lboost_system -lcppnetlib-uri
 
 
DISTCLEANFILES = \
        autoconf.h
 
AM_CPPFLAGS = -I\$(top_srcdir)/src
ALLEND
mv sample.h  bbkanba.h
cat > Debugger.h <<ALLEND
/* eCAP ClamAV Adapter  http://www.e-cap.org/
 * Copyright (C) 2011 The Measurement Factory.
 * Distributed under GPL v2 without any warranty.  */
 
#ifndef ECAP_MBAIDU_ADAPTER_DEBUGGER_H
#define ECAP_MBAIDU_ADAPTER_DEBUGGER_H
 
#include <libecap/common/log.h>
#include <iosfwd>
 
using libecap::ilNormal;
using libecap::ilCritical;
using libecap::flXaction;
using libecap::flApplication;
using libecap::mslLarge;
 
// TODO: rename to Log
 
// libecap::host::openDebug/closeDebug calls wrapper for safety and convenience
class Debugger {
    public:
        explicit Debugger(const libecap::LogVerbosity lv); // opens
        ~Debugger(); // closes
 
        // logs a message if host enabled debugging at the specified level
        template <class T>
        const Debugger &operator <<(const T &msg) const {
            if (debug)
                *debug << msg;
            return *this;
        }
 
    private:
        /* prohibited and not implemented */
        Debugger(const Debugger&);
        Debugger &operator=(const Debugger&);
 
        std::ostream *debug; // host-provided debug ostream or nil
};
 
#endif
ALLEND
cat > Debugger.cc <<ALLEND
/* eCAP ClamAV Adapter   http://www.e-cap.org/
 * Copyright (C) 2011 The Measurement Factory.
 * Distributed under GPL v2 without any warranty.  */
 
#include "bbkanba.h"
#include "Debugger.h"
#include <libecap/common/registry.h>
#include <libecap/host/host.h>
#include <iostream>
 
// TODO: support automated prefixing of log messages
 
Debugger::Debugger(const libecap::LogVerbosity lv):
    debug(libecap::MyHost().openDebug(lv)) {
}
 
Debugger::~Debugger() {
    if (debug)
        libecap::MyHost().closeDebug(debug);
}
ALLEND
cd ..
sed -i -e 's/AC_INIT.*/AC_INIT(eCAP bbkanba Adapter, 0.0.1, [email protected], eCAP_bbkanba_Adapter)/' configure.in
sed -i -e 's/AC_CONFIG_SRCDIR.*/AC_CONFIG_SRCDIR([src\/bbkanba.h])/' configure.in
touch  ./NEWS
touch  ./AUTHORS
touch  ./ChangeLog
touch ./COPYING
autoreconf -ivf
./configure PKG_CONFIG_PATH=/usr/local/lib/pkgconfig
make
make install

sed -i -e '/.*bbkanba.h.*/ a\#include "Debugger.h"\n#include <algorithm>' adapter_bbkanba.cc

###install boost####
yum -y install icu libicu libicu-devel python python-devel
wget http://sourceforge.net/projects/boost/files/boost/1.53.0/boost_1_53_0.tar.gz/download
tar -zxf boost_1_53_0.tar.gz
cd  boost_1_53_0
./bootstrap.sh --prefix=/usr/local/boost_1_53_0
./b2 install
ln -s /usr/local/boost_1_53_0/lib/libboost_* /usr/local/lib/
ln -s /usr/local/boost_1_53_0/include/boost /usr/local/include/boost
echo "/usr/local/lib" > /etc/ld.so.conf.d/usrlocallib.conf
ldconfig
###install cpp-netlib-0.9.4####
wget http://dl.atrpms.net/el6-x86_64/atrpms/stable/atrpms-repo-6-6.el6.x86_64.rpm
rpm -Uvh atrpms-repo*rpm
yum -y --enablerepo=atrpms-testing install cmake
wget https://github.com/downloads/cpp-netlib/cpp-netlib/cpp-netlib-0.9.4.zip
unzip cpp-netlib-0.9.4.zip
cd cpp-netlib-0.9.4
sed -i -e '/if (Boost_FOUND)/ a\set (CMAKE_CXX_FLAGS "-lrt -fPIC")' CMakeLists.txt
mkdir cpp-netlib-build
cd cpp-netlib-build
cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ ..
make -j4

cp libs/network/src/*.a /usr/local/lib/
cd ..
cp -r boost/* /usr/local/include/boost/
ldconfig

#include "bbkanba.h"
#include "Debugger.h"
#include <iostream>
#include <algorithm>
#include <libecap/common/registry.h>
#include <libecap/common/errors.h>
#include <libecap/common/message.h>
#include <libecap/common/header.h>
#include <libecap/common/names.h>
#include <libecap/common/named_values.h>
#include <libecap/host/host.h>
#include <libecap/adapter/service.h>
#include <libecap/adapter/xaction.h>
#include <libecap/host/xaction.h>
#include <boost/network/uri.hpp>
#include <boost/network/uri/uri_io.hpp>
#include <boost/network/protocol/http/client.hpp>
using namespace boost::network;

namespace Adapter { // not required, but adds clarity
using   libecap::size_type;
typedef libecap::RequestLine *CLRLP;

class Service: public libecap::adapter::Service {
    public:
        // About
        virtual std::string uri() const; // unique across all vendors
        virtual std::string tag() const; // changes with version and config
        virtual void describe(std::ostream &os) const; // free-format info

        // Configuration
        virtual void configure(const libecap::Options &cfg);
        virtual void reconfigure(const libecap::Options &cfg);

        // Lifecycle
        virtual void start(); // expect makeXaction() calls
        virtual void stop(); // no more makeXaction() calls until start()
        virtual void retire(); // no more makeXaction() calls

        // Scope (XXX: this may be changed to look at the whole header)
        virtual bool wantsUrl(const char *url) const;

        // Work
        virtual libecap::adapter::Xaction *makeXaction(libecap::host::Xaction *hostx);
};

class Xaction: public libecap::adapter::Xaction {
    public:
        Xaction(libecap::shared_ptr<Service> s, libecap::host::Xaction *x);
        virtual ~Xaction();

        // meta-information for the host transaction
        virtual const libecap::Area option(const libecap::Name &name) const;
        virtual void visitEachOption(libecap::NamedValueVisitor &visitor) const;

        // lifecycle
        virtual void start();
        virtual void stop();

        // adapted body transmission control
        virtual void abDiscard();
        virtual void abMake();
        virtual void abMakeMore();
        virtual void abStopMaking();

        // adapted body content extraction and consumption
        virtual libecap::Area abContent(size_type offset, size_type size);
        virtual void abContentShift(size_type size);

        // virgin body state notification
        virtual void noteVbContentDone(bool atEnd);
        virtual void noteVbContentAvailable();

        // libecap::Callable API, via libecap::host::Xaction
        virtual bool callable() const;

    protected:
        void stopVb(); // stops receiving vb (if we are receiving it)

        void getUri(libecap::shared_ptr<libecap::Message> &);
        void goToUrl( std::string orgUrl,std::string host,std::string state);
        void debugAction(const std::string &action,const bool &showOrgUrl=true);
        libecap::host::Xaction *lastHostCall(); // clears hostx

    private:
        CLRLP requestLine;
        libecap::Area uri; // Request-URI from headers, for logging
        libecap::shared_ptr<const Service> service; // configuration access
        libecap::host::Xaction *hostx; // Host transaction rep

        typedef enum { opUndecided, opOn, opComplete, opNever } OperationState;
        typedef enum { localWebServer, normal } OprationAdaptedState;
        OperationState receivingVb;
        OperationState sendingAb;
        OprationAdaptedState adaptedGotoAction;
};

static const std::string CfgErrorPrefix =
    "eBBkanba Adapter: configuration error: ";

} // namespace Adapter

std::string Adapter::Service::uri() const {
    return "ecap://bbkanba.com/bbkanba";
}

std::string Adapter::Service::tag() const {
    return PACKAGE_VERSION;
}

void Adapter::Service::describe(std::ostream &os) const {
    os << "A eBBkanba adapter from " << PACKAGE_NAME << " v" << PACKAGE_VERSION;
}

void Adapter::Service::configure(const libecap::Options &cfg) {
}

void Adapter::Service::reconfigure(const libecap::Options &cfg) {
}
void Adapter::Service::start() {
    libecap::adapter::Service::start();
}

void Adapter::Service::stop() {
    libecap::adapter::Service::stop();
}

void Adapter::Service::retire() {
    libecap::adapter::Service::stop();
}

bool Adapter::Service::wantsUrl(const char *url) const {
    return true; // no-op is applied to all messages
}

libecap::adapter::Xaction *Adapter::Service::makeXaction(libecap::host::Xaction *hostx) {
    return new Adapter::Xaction(std::tr1::static_pointer_cast<Service>(self),hostx);
}

Adapter::Xaction::Xaction(libecap::shared_ptr<Service> aService,libecap::host::Xaction *x):
    service(aService),
    hostx(x),
    receivingVb(opUndecided),
    sendingAb(opUndecided),
    adaptedGotoAction(normal){
}

Adapter::Xaction::~Xaction() {
    if (libecap::host::Xaction *x = hostx) {
        hostx = 0;
        requestLine = 0;
        x->adaptationAborted();
    }
}

const libecap::Area Adapter::Xaction::option(const libecap::Name &) const {
    return libecap::Area(); // this transaction has no meta-information
}

void Adapter::Xaction::visitEachOption(libecap::NamedValueVisitor &) const {
    // this transaction has no meta-information to pass to the visitor
}

void Adapter::Xaction::start() {
    Must(hostx);

    //static int scannerCount = 0;
    //++scannerCount;
    //Debugger(ilNormal|flApplication) << "eBBkanba: " << "Initializing eBBkanba engine #" << scannerCount << ".";

    //查看请求是否包含http头以外的数据
    if (hostx->virgin().body()) {
        receivingVb = opOn;
        hostx->vbMake(); // ask host to supply virgin body
    } else {
        // we are not interested in vb if there is not one
        receivingVb = opNever;
    }

    //获取用户ip
    libecap::Header::Value clientIP = hostx->option(libecap::metaClientIp);

    /* adapt message header ,copy一份http请求的纯原始副本,然后下面可能会修改内容*/
    libecap::shared_ptr<libecap::Message> adapted = hostx->virgin().clone();
    Must(adapted != 0);
    // delete ContentLength header because we may change the length
    // unknown length may have performance implications for the host
    //获取用户请求的url
    getUri(adapted);

    if (uri.size > 0) {
        //adapted->header().removeAny(libecap::headerContentLength);
        uri::uri url_path(uri.toString());
        std::string url_path_tolower = url_path.host();
        std::transform(url_path_tolower.begin(), url_path_tolower.end(),url_path_tolower.begin(), ::tolower);
        if (url_path_tolower != "127.0.0.1") {
            http::client::response response = http::client().get(http::request("http://127.0.0.1:9090/check.php?uip="+clientIP.toString()));
            std::string check = static_cast<std::string>(body(response));
            if ( check == "0" ){
                //则表示用户没有经过认证
                goToUrl(uri.toString(),"http://127.0.0.1:9090","0");
            }
            if( check == "1" ){
                //表示已经过期
                goToUrl(uri.toString(),"http://127.0.0.1:9090","1");
            }
        }
    }

    // 最后返回我们修改过的用户请求
    if (!adapted->body()) {
        sendingAb = opNever; // there is nothing to send
        lastHostCall()->useAdapted(adapted);
    } else {
        hostx->useAdapted(adapted);
    }
}

void Adapter::Xaction::stop() {
    hostx = 0;
    requestLine = 0;
}

void Adapter::Xaction::abDiscard()
{
    Must(sendingAb == opUndecided); // have not started yet
    sendingAb = opNever;
    // we do not need more vb if the host is not interested in ab
    stopVb();
}

void Adapter::Xaction::abMake()
{
    Must(sendingAb == opUndecided); // have not yet started or decided not to send
    Must(hostx->virgin().body()); // that is our only source of ab content

    // we are or were receiving vb
    Must(receivingVb == opOn || receivingVb == opComplete);

    sendingAb = opOn;
    hostx->noteAbContentAvailable();
}

void Adapter::Xaction::abMakeMore()
{
    Must(receivingVb == opOn); // a precondition for receiving more vb
    hostx->vbMakeMore();
}

void Adapter::Xaction::abStopMaking()
{
    sendingAb = opComplete;
    // we do not need more vb if the host is not interested in more ab
    stopVb();
}

libecap::Area Adapter::Xaction::abContent(size_type offset, size_type size) {
    Must(sendingAb == opOn || sendingAb == opComplete);
    return hostx->vbContent(offset, size);
}

void Adapter::Xaction::abContentShift(size_type size) {
    Must(sendingAb == opOn || sendingAb == opComplete);
    hostx->vbContentShift(size);
}

void Adapter::Xaction::noteVbContentDone(bool atEnd)
{
    Must(receivingVb == opOn);
    receivingVb = opComplete;
    if (sendingAb == opOn) {
        hostx->noteAbContentDone(atEnd);
        sendingAb = opComplete;
    }
}

void Adapter::Xaction::noteVbContentAvailable()
{
    Must(receivingVb == opOn);
    if (sendingAb == opOn)
        hostx->noteAbContentAvailable();
}

bool Adapter::Xaction::callable() const {
    return hostx != 0; // no point to call us if we are done
}

// tells the host that we are not interested in [more] vb
// if the host does not know that already
void Adapter::Xaction::stopVb() {
    if (receivingVb == opOn) {
        hostx->vbStopMaking();
        receivingVb = opComplete;
    } else {
        // we already got the entire body or refused it earlier
        Must(receivingVb != opUndecided);
    }
}
//重新定位请求地址,到用户认证页面,并把用户请求url作为参数传入
void Adapter::Xaction::goToUrl(std::string orgUrl,std::string new_host, std::string state)
{
    std::string new_url_path = new_host + "/?state=" + state + "&orgUrl=" + orgUrl;
    const libecap::Header::Value new_url_path_r = libecap::Area::FromTempString(new_url_path);
    debugAction("new URL: " + new_url_path);
    requestLine->uri(new_url_path_r);
}
void Adapter::Xaction::getUri(libecap::shared_ptr<libecap::Message> &adapted)
{
    if (!hostx)
        return;
    if ( (requestLine = dynamic_cast<CLRLP>(&adapted->firstLine())) )
        uri = requestLine->uri();
}

void Adapter::Xaction::debugAction(const std::string &actDescript,const bool &showOrgUrl)
{
    std::string descipt (actDescript);
    if(showOrgUrl)
        descipt += " ( org URL: " + uri.toString() + " )";
    Debugger(ilNormal|flApplication) << "eBBkanba: " << descipt ;
}

// this method is used to make the last call to hostx transaction
// last call may delete adapter transaction if the host no longer needs it
// TODO: replace with hostx-independent "done" method
libecap::host::Xaction *Adapter::Xaction::lastHostCall() {
    libecap::host::Xaction *x = hostx;
    Must(x);
    hostx = 0;
    requestLine = 0;
    return x;
}

// create the adapter and register with libecap to reach the host application
static const bool Registered = (libecap::RegisterService(new Adapter::Service), true);