You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
474 lines
17 KiB
474 lines
17 KiB
/*
|
|
Copyright (c) 2003 Malte Starostik <malte@kde.org>
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public License
|
|
along with this library; see the file COPYING.LIB. If not, write to
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
|
|
#include <cstdlib>
|
|
#include <vector>
|
|
#include <algorithm>
|
|
#include <ctime>
|
|
#include <cstring>
|
|
|
|
#include <netdb.h>
|
|
#include <sys/types.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
#include <unistd.h>
|
|
|
|
#include <tqregexp.h>
|
|
#include <tqstring.h>
|
|
|
|
#include <kurl.h>
|
|
#include <kjs/object.h>
|
|
#include <kresolver.h>
|
|
|
|
#include "script.h"
|
|
|
|
using namespace KJS;
|
|
|
|
TQString UString::qstring() const
|
|
{
|
|
return TQString( reinterpret_cast< const TQChar* >( data() ), size() );
|
|
}
|
|
|
|
UString::UString( const TQString &s )
|
|
{
|
|
UChar* data = new UChar[ s.length() ];
|
|
std::memcpy( data, s.unicode(), s.length() * sizeof( UChar ) );
|
|
rep = Rep::create( data, s.length() );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
class Address
|
|
{
|
|
public:
|
|
struct Error {};
|
|
static Address resolve( const UString& host )
|
|
{ return Address( host.qstring(), false ); }
|
|
static Address parse( const UString& ip )
|
|
{ return Address( ip.qstring(), true ); }
|
|
|
|
operator in_addr_t() const {
|
|
const sockaddr_in* sin = m_address;
|
|
return sin->sin_addr.s_addr;
|
|
}
|
|
|
|
operator String() const { return String( m_address.ipAddress().toString() ); }
|
|
|
|
private:
|
|
Address( const TQString& host, bool numeric )
|
|
{
|
|
int flags = 0;
|
|
|
|
if ( numeric )
|
|
flags = KNetwork::KResolver::NoResolve;
|
|
|
|
KNetwork::KResolverResults addresses =
|
|
KNetwork::KResolver::resolve( host, TQString::null, flags,
|
|
KNetwork::KResolver::IPv4Family );
|
|
|
|
if ( addresses.isEmpty() )
|
|
throw Error();
|
|
|
|
m_address = addresses.first().address().asInet();
|
|
}
|
|
|
|
KNetwork::KInetSocketAddress m_address;
|
|
};
|
|
|
|
struct Function : public ObjectImp
|
|
{
|
|
struct ResolveError {};
|
|
|
|
virtual bool implementsCall() const { return true; }
|
|
|
|
static int findString( const UString& s, const char* const* values )
|
|
{
|
|
int index = 0;
|
|
UString lower = s.toLower();
|
|
for ( const char* const* p = values; *p; ++p, ++index )
|
|
if ( lower == *p ) return index;
|
|
return -1;
|
|
}
|
|
|
|
static const tm* getTime( ExecState* exec, const List& args )
|
|
{
|
|
time_t now = std::time( 0 );
|
|
if ( args[ args.size() - 1 ].toString( exec ).toLower() == "gmt" )
|
|
return std::gmtime( &now );
|
|
else return std::localtime( &now );
|
|
}
|
|
|
|
Boolean checkRange( int value, int min, int max )
|
|
{
|
|
return ( min <= max && value >= min && value <= max ) ||
|
|
( min > max && ( value <= min || value >= max ) );
|
|
}
|
|
};
|
|
|
|
// isPlainHostName( host )
|
|
// @returns true if @p host doesn't contains a domain part
|
|
struct IsPlainHostName : public Function
|
|
{
|
|
virtual Value call( ExecState* exec, Object&, const List& args )
|
|
{
|
|
if ( args.size() != 1 ) return Undefined();
|
|
return Boolean( args[ 0 ].toString( exec ).find( "." ) == -1 );
|
|
}
|
|
};
|
|
|
|
// dnsDomainIs( host, domain )
|
|
// @returns true if the domain part of @p host matches @p domain
|
|
struct DNSDomainIs : public Function
|
|
{
|
|
virtual Value call( ExecState* exec, Object&, const List& args )
|
|
{
|
|
if ( args.size() != 2 ) return Undefined();
|
|
TQString host = args[ 0 ].toString( exec ).qstring().lower();
|
|
TQString domain = args[ 1 ].toString( exec ).qstring().lower();
|
|
return Boolean( host.endsWith( domain ) );
|
|
}
|
|
};
|
|
|
|
// localHostOrDomainIs( host, fqdn )
|
|
// @returns true if @p host is unqualified or equals @p fqdn
|
|
struct LocalHostOrDomainIs : public Function
|
|
{
|
|
virtual Value call( ExecState* exec, Object&, const List& args )
|
|
{
|
|
if ( args.size() != 2 ) return Undefined();
|
|
UString host = args[ 0 ].toString( exec ).toLower();
|
|
if ( host.find( "." ) == -1 ) return Boolean( true );
|
|
UString fqdn = args[ 1 ].toString( exec ).toLower();
|
|
return Boolean( host == fqdn );
|
|
}
|
|
};
|
|
|
|
// isResolvable( host )
|
|
// @returns true if host can be resolved via DNS
|
|
struct IsResolvable : public Function
|
|
{
|
|
virtual Value call( ExecState* exec, Object&, const List& args )
|
|
{
|
|
if ( args.size() != 1 ) return Undefined();
|
|
try { ::Address::resolve( args[ 0 ].toString( exec ) ); }
|
|
catch ( const Address::Error& ) { return Boolean( false ); }
|
|
return Boolean( true );
|
|
}
|
|
};
|
|
|
|
// isInNet( host, subnet, mask )
|
|
// @returns true if @p host is within the IP subnet
|
|
// specified via @p subnet and @p mask
|
|
struct IsInNet : public Function
|
|
{
|
|
virtual Value call( ExecState* exec, Object&, const List& args )
|
|
{
|
|
if ( args.size() != 3 ) return Undefined();
|
|
try
|
|
{
|
|
in_addr_t host = Address::resolve( args[ 0 ].toString( exec ) );
|
|
in_addr_t subnet = Address::parse( args[ 1 ].toString( exec ) );
|
|
in_addr_t mask = Address::parse( args[ 2 ].toString( exec ) );
|
|
return Boolean( ( host & mask ) == ( subnet & mask ) );
|
|
}
|
|
catch ( const Address::Error& )
|
|
{
|
|
return Undefined();
|
|
}
|
|
}
|
|
};
|
|
|
|
// dnsResolve( host )
|
|
// @returns the IP address of @p host in dotted quad notation
|
|
struct DNSResolve : public Function
|
|
{
|
|
virtual Value call( ExecState* exec, Object&, const List& args )
|
|
{
|
|
if ( args.size() != 1 ) return Undefined();
|
|
try { return String(Address::resolve( args[ 0 ].toString( exec ))); }
|
|
catch ( const Address::Error& ) { return Undefined(); }
|
|
}
|
|
};
|
|
|
|
// myIpAddress()
|
|
// @returns the local machine's IP address in dotted quad notation
|
|
struct MyIpAddress : public Function
|
|
{
|
|
virtual Value call( ExecState*, Object&, const List& args )
|
|
{
|
|
if ( args.size() ) return Undefined();
|
|
char hostname[ 256 ];
|
|
gethostname( hostname, 255 );
|
|
hostname[ 255 ] = 0;
|
|
try { return String(Address::resolve( hostname )); }
|
|
catch ( const Address::Error& ) { return Undefined(); }
|
|
}
|
|
};
|
|
|
|
// dnsDomainLevels( host )
|
|
// @returns the number of dots ('.') in @p host
|
|
struct DNSDomainLevels : public Function
|
|
{
|
|
virtual Value call( ExecState* exec, Object&, const List& args )
|
|
{
|
|
if ( args.size() != 1 ) return Undefined();
|
|
UString host = args[ 0 ].toString( exec );
|
|
if ( host.isNull() ) return Number( 0 );
|
|
return Number( std::count(
|
|
host.data(), host.data() + host.size(), '.' ) );
|
|
}
|
|
};
|
|
|
|
// shExpMatch( str, pattern )
|
|
// @returns true if @p str matches the shell @p pattern
|
|
struct ShExpMatch : public Function
|
|
{
|
|
virtual Value call( ExecState* exec, Object&, const List& args )
|
|
{
|
|
if ( args.size() != 2 ) return Undefined();
|
|
TQRegExp pattern( args[ 1 ].toString( exec ).qstring(), true, true );
|
|
return Boolean( pattern.exactMatch(args[ 0 ].toString( exec ).qstring()) );
|
|
}
|
|
};
|
|
|
|
// weekdayRange( day [, "GMT" ] )
|
|
// weekdayRange( day1, day2 [, "GMT" ] )
|
|
// @returns true if the current day equals day or between day1 and day2 resp.
|
|
// If the last argument is "GMT", GMT timezone is used, otherwise local time
|
|
struct WeekdayRange : public Function
|
|
{
|
|
virtual Value call( ExecState* exec, Object&, const List& args )
|
|
{
|
|
if ( args.size() < 1 || args.size() > 3 ) return Undefined();
|
|
static const char* const days[] =
|
|
{ "sun", "mon", "tue", "wed", "thu", "fri", "sat", 0 };
|
|
int d1 = findString( args[ 0 ].toString( exec ), days );
|
|
if ( d1 == -1 ) return Undefined();
|
|
|
|
int d2 = findString( args[ 1 ].toString( exec ), days );
|
|
if ( d2 == -1 ) d2 = d1;
|
|
return checkRange( getTime( exec, args )->tm_wday, d1, d2 );
|
|
}
|
|
};
|
|
|
|
// dateRange( day [, "GMT" ] )
|
|
// dateRange( day1, day2 [, "GMT" ] )
|
|
// dateRange( month [, "GMT" ] )
|
|
// dateRange( month1, month2 [, "GMT" ] )
|
|
// dateRange( year [, "GMT" ] )
|
|
// dateRange( year1, year2 [, "GMT" ] )
|
|
// dateRange( day1, month1, day2, month2 [, "GMT" ] )
|
|
// dateRange( month1, year1, month2, year2 [, "GMT" ] )
|
|
// dateRange( day1, month1, year1, day2, month2, year2 [, "GMT" ] )
|
|
// @returns true if the current date (GMT or local time according to
|
|
// presence of "GMT" as last argument) is within the given range
|
|
struct DateRange : public Function
|
|
{
|
|
virtual Value call( ExecState* exec, Object&, const List& args )
|
|
{
|
|
if ( args.size() < 1 || args.size() > 7 ) return Undefined();
|
|
static const char* const months[] =
|
|
{ "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "nov", "dec", 0 };
|
|
|
|
std::vector< int > values;
|
|
for ( int i = 0; i < args.size(); ++i )
|
|
{
|
|
int value = -1;
|
|
if ( args[ i ].isA( NumberType ) )
|
|
value = args[ i ].toInteger( exec );
|
|
else value = findString( args[ i ].toString( exec ), months );
|
|
if ( value >= 0 ) values.push_back( value );
|
|
else break;
|
|
}
|
|
|
|
const tm* now = getTime( exec, args );
|
|
|
|
// day1, month1, year1, day2, month2, year2
|
|
if ( values.size() == 6 )
|
|
return checkRange( ( now->tm_year + 1900 ) * 372 + now->tm_mon * 31 + now->tm_mday,
|
|
values[ 2 ] * 372 + values[ 1 ] * 31 + values[ 0 ],
|
|
values[ 5 ] * 372 + values[ 4 ] * 31 + values[ 3 ] );
|
|
|
|
// day1, month1, day2, month2
|
|
else if ( values.size() == 4 &&
|
|
values[ 1 ] < 12 &&
|
|
values[ 3 ] < 12 )
|
|
return checkRange( now->tm_mon * 31 + now->tm_mday,
|
|
values[ 1 ] * 31 + values[ 0 ],
|
|
values[ 3 ] * 31 + values[ 2 ] );
|
|
|
|
// month1, year1, month2, year2
|
|
else if ( values.size() == 4 )
|
|
return checkRange( ( now->tm_year + 1900 ) * 12 + now->tm_mon,
|
|
values[ 1 ] * 12 + values[ 0 ],
|
|
values[ 3 ] * 12 + values[ 2 ] );
|
|
|
|
// year1, year2
|
|
else if ( values.size() == 2 &&
|
|
values[ 0 ] >= 1000 &&
|
|
values[ 1 ] >= 1000 )
|
|
return checkRange( now->tm_year + 1900, values[ 0 ], values[ 1 ] );
|
|
|
|
// day1, day2
|
|
else if ( values.size() == 2 &&
|
|
args[ 0 ].isA( NumberType ) &&
|
|
args[ 1 ].isA( NumberType ) )
|
|
return checkRange( now->tm_mday, values[ 0 ], values[ 1 ] );
|
|
|
|
// month1, month2
|
|
else if ( values.size() == 2 )
|
|
return checkRange( now->tm_mon, values[ 0 ], values[ 1 ] );
|
|
|
|
// year
|
|
else if ( values.size() == 1 && values[ 0 ] >= 1000 )
|
|
return checkRange( now->tm_year + 1900, values[ 0 ], values[ 0 ] );
|
|
|
|
// day
|
|
else if ( values.size() == 1 && args[ 0 ].isA( NumberType ) )
|
|
return checkRange( now->tm_mday, values[ 0 ], values[ 0 ] );
|
|
|
|
// month
|
|
else if ( values.size() == 1 )
|
|
return checkRange( now->tm_mon, values[ 0 ], values[ 0 ] );
|
|
|
|
else return Undefined();
|
|
}
|
|
};
|
|
|
|
// timeRange( hour [, "GMT" ] )
|
|
// timeRange( hour1, hour2 [, "GMT" ] )
|
|
// timeRange( hour1, min1, hour2, min2 [, "GMT" ] )
|
|
// timeRange( hour1, min1, sec1, hour2, min2, sec2 [, "GMT" ] )
|
|
// @returns true if the current time (GMT or local based on presence
|
|
// of "GMT" argument) is within the given range
|
|
struct TimeRange : public Function
|
|
{
|
|
virtual Value call( ExecState* exec, Object&, const List& args )
|
|
{
|
|
if ( args.size() < 1 || args.size() > 7 ) return Undefined();
|
|
|
|
std::vector< int > values;
|
|
for ( int i = 0; i < args.size(); ++i )
|
|
if ( args[ i ].isA( NumberType ) )
|
|
values.push_back( args[ i ].toInteger( exec ) );
|
|
else break;
|
|
|
|
const tm* now = getTime( exec, args );
|
|
|
|
// hour1, min1, sec1, hour2, min2, sec2
|
|
if ( values.size() == 6 )
|
|
return checkRange( now->tm_hour * 3600 + now->tm_min * 60 + now->tm_sec,
|
|
values[ 0 ] * 3600 + values[ 1 ] * 60 + values[ 2 ],
|
|
values[ 3 ] * 3600 + values[ 4 ] * 60 + values[ 5 ] );
|
|
|
|
// hour1, min1, hour2, min2
|
|
else if ( values.size() == 4 )
|
|
return checkRange( now->tm_hour * 60 + now->tm_min,
|
|
values[ 0 ] * 60 + values[ 1 ],
|
|
values[ 2 ] * 60 + values[ 3 ] );
|
|
|
|
// hour1, hour2
|
|
else if ( values.size() == 2 )
|
|
return checkRange( now->tm_hour, values[ 0 ], values[ 1 ] );
|
|
|
|
// hour
|
|
else if ( values.size() == 1 )
|
|
return checkRange( now->tm_hour, values[ 0 ], values[ 0 ] );
|
|
|
|
else return Undefined();
|
|
}
|
|
};
|
|
|
|
void registerFunctions( ExecState* exec, Object& global )
|
|
{
|
|
global.put( exec, "isPlainHostName",
|
|
Object( new IsPlainHostName ) );
|
|
global.put( exec, "dnsDomainIs",
|
|
Object( new DNSDomainIs ) );
|
|
global.put( exec, "localHostOrDomainIs",
|
|
Object( new LocalHostOrDomainIs ) );
|
|
global.put( exec, "isResolvable",
|
|
Object( new IsResolvable ) );
|
|
global.put( exec, "isInNet",
|
|
Object( new IsInNet ) );
|
|
global.put( exec, "dnsResolve",
|
|
Object( new DNSResolve ) );
|
|
global.put( exec, "myIpAddress",
|
|
Object( new MyIpAddress ) );
|
|
global.put( exec, "dnsDomainLevels",
|
|
Object( new DNSDomainLevels ) );
|
|
global.put( exec, "shExpMatch",
|
|
Object( new ShExpMatch ) );
|
|
global.put( exec, "weekdayRange",
|
|
Object( new WeekdayRange ) );
|
|
global.put( exec, "dateRange",
|
|
Object( new DateRange ) );
|
|
global.put( exec, "timeRange",
|
|
Object( new TimeRange ) );
|
|
}
|
|
}
|
|
|
|
namespace KPAC
|
|
{
|
|
Script::Script( const TQString& code )
|
|
{
|
|
ExecState* exec = m_interpreter.globalExec();
|
|
Object global = m_interpreter.globalObject();
|
|
registerFunctions( exec, global );
|
|
|
|
Completion result = m_interpreter.evaluate( code );
|
|
if ( result.complType() == Throw )
|
|
throw Error( result.value().toString( exec ).qstring() );
|
|
}
|
|
|
|
TQString Script::evaluate( const KURL& url )
|
|
{
|
|
ExecState *exec = m_interpreter.globalExec();
|
|
Value findFunc = m_interpreter.globalObject().get( exec, "FindProxyForURL" );
|
|
Object findObj = Object::dynamicCast( findFunc );
|
|
if (!findObj.isValid() || !findObj.implementsCall())
|
|
throw Error( "No such function FindProxyForURL" );
|
|
|
|
KURL cleanUrl = url;
|
|
cleanUrl.setPass(QString());
|
|
cleanUrl.setUser(QString());
|
|
if (cleanUrl.protocol().lower() == "https") {
|
|
cleanUrl.setPath(QString());
|
|
cleanUrl.setQuery(QString());
|
|
}
|
|
|
|
Object thisObj;
|
|
List args;
|
|
args.append(String(cleanUrl.url()));
|
|
args.append(String(cleanUrl.host()));
|
|
Value retval = findObj.call( exec, thisObj, args );
|
|
|
|
if ( exec->hadException() ) {
|
|
Value ex = exec->exception();
|
|
exec->clearException();
|
|
throw Error( ex.toString( exec ).qstring() );
|
|
}
|
|
|
|
return retval.toString( exec ).qstring();
|
|
}
|
|
}
|
|
|
|
// vim: ts=4 sw=4 et
|