/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */
/*
 * mkautocf.c: Proxy auto-config parser and evaluator
 * Ari Luotonen
 *
 * Updated and Documented by Judson Valeski 11/19/1997
 */
#include "mkutils.h"    /* LF */
#include "mktcp.h"
#include "netutils.h"
#include "prsystem.h"
#include "mkpadpac.h"
#include "net_xp_file.h"
#include <time.h>
#include "mkautocf.h"
#include "xp_mem.h"     /* PR_NEWZAP() */
#ifndef XP_MAC
#include <sys/types.h>
#endif
#include "libi18n.h"
#include "mkgeturl.h"
#include "mkstream.h"
#include "mkgeturl.h"
#include "mkformat.h"
#include "mime.h"
#include "cvactive.h"
#include "gui.h"
#include "msgcom.h"
#include "prefapi.h"
#define WANT_ENUM_STRING_IDS
#include "allxpstr.h"
#undef WANT_ENUM_STRING_IDS
#include "mkreg.h"

#include "prnetdb.h"

#include "net.h"
#include "libmocha.h"
#include "jsapi.h"
#include "jscompat.h"
#include "jspubtd.h"
#include "jsautocf.h"

/* for XP_GetString() */
#include "xpgetstr.h"
#ifdef NOT
extern int XP_BAD_KEYWORD_IN_PROXY_AUTOCFG;
extern int XP_RETRY_AGAIN_PROXY;
extern int XP_RETRY_AGAIN_SOCKS;
extern int XP_RETRY_AGAIN_PROXY_OR_SOCKS;
extern int XP_PROXY_UNAVAILABLE_TRY_AGAIN;
extern int XP_ALL_PROXIES_DOWN_TRY_AGAIN;
extern int XP_ALL_SOCKS_DOWN;
extern int XP_ALL_DOWN_MIX;
extern int XP_OVERRIDE_PROXY;
extern int XP_OVERRIDE_SOCKS;
extern int XP_OVERRIDE_MIX;
extern int XP_STILL_OVERRIDE_PROXY;
extern int XP_STILL_OVERRIDE_SOCKS;
extern int XP_STILL_OVERRIDE_MIX;
extern int XP_NO_CONFIG_RECIEVED;
extern int XP_NO_CONFIG_RECEIVED_NO_FAILOVER;
extern int XP_EMPTY_CONFIG_USE_PREV;
extern int XP_BAD_CONFIG_USE_PREV;
extern int XP_BAD_CONFIG_IGNORED;
extern int XP_BAD_TYPE_USE_PREV;
extern int XP_BAD_TYPE_CONFIG_IGNORED;
extern int XP_CONF_LOAD_FAILED_IGNORED;
extern int XP_CONF_LOAD_FAILED_NO_FAILOVER;
extern int XP_CONF_LOAD_FAILED_USE_PREV;
extern int XP_EVEN_SAVED_IS_BAD;
extern int XP_CONFIG_LOAD_ABORTED;
extern int XP_CONFIG_BLAST_WARNING;
extern int XP_RECEIVING_PROXY_AUTOCFG;
extern int XP_AUTOADMIN_MISSING;
#endif

#define PACF_MIN_RETRY_AFTER    300
#define PACF_MIN_RETRY_ASK       25
#define PACF_AUTO_RETRY_AFTER  1800
#define PACF_DIRECT_INTERVAL   1200
#define PACF_RETRY_OK_AFTER      30

/* Types of retrievals: retrieve directly, thru a proxy, or using socks. */
typedef enum _PACF_Type {
    PACF_TYPE_INVALID = 0,
    PACF_TYPE_DIRECT,
    PACF_TYPE_PROXY,
    PACF_TYPE_SOCKS
} PACF_Type;

/* Info about the proxy/socks server hostname/IP address and port. 
 * These nodes are kept in a list so we don't have to parse the pac file
 * every time to gather proxy/socks info. */
typedef struct _PACF_Node {
    PACF_Type   type;   /* direct | proxy | socks */
    char *      addr;
    u_long      socks_addr;
    short       socks_port;
    int         retries;
    time_t      retrying;
    time_t      last_try;
    time_t      down_since;
} PACF_Node;

/* Private object for the proxy config loader stream. */
typedef struct _PACF_Object {
   MWContext *  context;
   int          flag;
} PACF_Object;

/* A struct for holding queued state.
 *
 * The state is saved when NET_GetURL() is called for the first time,
 * and the proxy autoconfig retrieve has to be started (and finished)
 * before the first actual document can be loaded.
 *
 * A pre-exit function for the proxy autoconfig URL restarts the
 * original URL retrieve by calling NET_GetURL() again with the
 * same parameters. */
typedef struct _PACF_QueuedState {
    URL_Struct *        URL_s;
    FO_Present_Types    output_format;
    MWContext *         window_id;
    Net_GetUrlExitFunc* exit_routine;
} PACF_QueuedState;

typedef enum {
    PACF_SECONDARY_URL,
    PACF_BINDINGS
} pc_slot;

/* Declared in mkgeturl.c. NET_GetURL uses these variables to determine
 * whether or not the pac file has been loaded. */
extern XP_Bool NET_FindProxyInJSC(void);
extern XP_Bool NET_GlobalAcLoaded;
extern PRBool NET_ProxyAcLoaded;

/* Private proxy auto-config variables */
PRIVATE Bool    pacf_do_failover  = TRUE;
PRIVATE Bool    pacf_loading      = FALSE;
PRIVATE Bool    pacf_ok           = FALSE;
PRIVATE char *  pacf_url          = NULL;
PRIVATE char *  pacf_src_buf      = NULL;
PRIVATE int     pacf_src_len      = 0;
PRIVATE XP_List*pacf_all_nodes    = NULL;
PRIVATE time_t  pacf_direct_until = (time_t)0;
PRIVATE int     pacf_direct_cnt   = 0;
PRIVATE PACF_QueuedState *queued_state = NULL;
PRIVATE XP_List*pacf_bad_keywords = NULL;

PRIVATE Bool	pacf_find_proxy_undefined = FALSE;

/* Javascript stuff. A javascript context does the interpretation and
 * compilation of the pac file. */
PRIVATE JSPropertySpec pc_props[] = {
    {"secondary", PACF_SECONDARY_URL},
    {"bindings",  PACF_BINDINGS},
    {0}
};

PRIVATE JSClass pc_class = {
    "ProxyConfig", 0,
    JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
    JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, JS_FinalizeStub
};

/* PRIVATE JSPropertySpec no_props[1] = { { NULL } }; */
PRIVATE JSObject *proxyConfig = NULL;
PRIVATE JSObject *globalConfig = NULL;
PRIVATE JSContext *configContext = NULL;

/* The javascript methods */
MODULE_PRIVATE JSBool PR_CALLBACK proxy_weekdayRange(JSContext *mc, JSObject *obj, unsigned int argc, jsval *argv, jsval *rval);
MODULE_PRIVATE JSBool PR_CALLBACK proxy_dateRange(JSContext *mc, JSObject *obj, unsigned int argc, jsval *argv, jsval *rval);
MODULE_PRIVATE JSBool PR_CALLBACK proxy_timeRange(JSContext *mc, JSObject *obj, unsigned int argc, jsval *argv, jsval *rval);
MODULE_PRIVATE JSBool PR_CALLBACK proxy_isPlainHostName(JSContext *mc, JSObject *obj, unsigned int argc, jsval *argv, jsval *rval);
MODULE_PRIVATE JSBool PR_CALLBACK proxy_dnsDomainLevels(JSContext *mc, JSObject *obj, unsigned int argc, jsval *argv, jsval *rval);
MODULE_PRIVATE JSBool PR_CALLBACK proxy_dnsDomainIs(JSContext *mc, JSObject *obj, unsigned int argc, jsval *argv, jsval *rval);
MODULE_PRIVATE JSBool PR_CALLBACK proxy_localHostOrDomainIs(JSContext *mc, JSObject *obj, unsigned int argc, jsval *argv, jsval *rval);
MODULE_PRIVATE JSBool PR_CALLBACK proxy_isResolvable(JSContext *mc, JSObject *obj, unsigned int argc, jsval *argv, jsval *rval);
MODULE_PRIVATE JSBool PR_CALLBACK proxy_dnsResolve(JSContext *mc, JSObject *obj, unsigned int argc, jsval *argv, jsval *rval);
MODULE_PRIVATE JSBool PR_CALLBACK proxy_isInNet(JSContext *mc, JSObject *obj, unsigned int argc, jsval *argv, jsval *rval);
MODULE_PRIVATE JSBool PR_CALLBACK proxy_myIpAddress(JSContext *mc, JSObject *obj, unsigned int argc, jsval *argv, jsval *rval);
MODULE_PRIVATE JSBool PR_CALLBACK proxy_regExpMatch(JSContext *mc, JSObject *obj, unsigned int argc, jsval *argv, jsval *rval);

PRIVATE JSFunctionSpec pc_methods[] = {
    { "weekdayRange",        proxy_weekdayRange,        3},
    { "dateRange",           proxy_dateRange,           7},
    { "timeRange",           proxy_timeRange,           7},
    { "isPlainHostName",     proxy_isPlainHostName,     1},
    { "dnsDomainLevels",     proxy_dnsDomainLevels,     1},
    { "dnsDomainIs",         proxy_dnsDomainIs,         2},
    { "localHostOrDomainIs", proxy_localHostOrDomainIs, 2},
    { "isResolvable",        proxy_isResolvable,        1},
    { "dnsResolve",          proxy_dnsResolve,          1},
    { "isInNet",             proxy_isInNet,             3},
    { "myIpAddress",         proxy_myIpAddress,         0},
    { "regExpMatch",         proxy_regExpMatch,         2},
    { "shExpMatch",          proxy_regExpMatch,         2},
    { NULL,                  NULL,                      0}
};

PRIVATE char *mkMethodString( int method ) {
  char *mstr= NULL;

  switch ( method ) {
	  case  URL_GET_METHOD: 
		mstr = PL_strdup("GET");
		break;
	  case URL_POST_METHOD:
		mstr = PL_strdup("POST");
		break;
	  case  URL_HEAD_METHOD:
		mstr = PL_strdup("HEAD");
		break;
	  case  URL_PUT_METHOD:
		mstr = PL_strdup("PUT");
		break;
	  case  URL_DELETE_METHOD:
		mstr = PL_strdup("DELETE");
		break;
	  case  URL_MKDIR_METHOD :
		mstr = PL_strdup("MKDIR");
		break;
	  case  URL_MOVE_METHOD:
		mstr = PL_strdup("MOVE");
		break;
	  case  URL_INDEX_METHOD:
		mstr = PL_strdup("INDEX");
		break;
	  case  URL_GETPROPERTIES_METHOD:
		mstr = PL_strdup("GETPROPERTIES");
		break;
  }
  return mstr;
}

PRIVATE char *msg2(char *fmt, char *prm) {
    char *msg = (char *)PR_Malloc(PL_strlen(fmt) + 100 +
				 (prm ? PL_strlen(prm) : 0));
    if (msg)
	sprintf(msg, fmt, prm ? prm : "-");

    return msg;
}

PRIVATE Bool confirm2(MWContext *context, char *fmt, char *prm) {
    Bool rv = TRUE;
    char *msg = msg2(fmt, prm);
    if (msg) {
	rv = FE_Confirm(context, msg);
	PR_Free(msg);
    }
    return rv;
}

PRIVATE void alert2(MWContext *context, char *fmt, char *prm) {
    char *msg = msg2(fmt, prm);
    if (msg) {
	FE_Alert(context, msg);
	PR_Free(msg);
    }
}

/* Returns a node representing a proxy/SOCKS server address or
 * direct access, and guarantees to return the same node if one
 * was already created for that address. */
PRIVATE PACF_Node *lookup_create_node(PACF_Type type, char *addr) {
    if (!pacf_all_nodes)
	pacf_all_nodes = XP_ListNew();

    /* Truncate at 64 characters -- gethostbyname() is evil */
    if (addr && PL_strlen(addr) > 64)
	addr[64] = '\0';

    if (!type || (!addr && (type == PACF_TYPE_PROXY ||
			    type == PACF_TYPE_SOCKS)))
      {
	  return NULL;
      }
    else
      {
	  XP_List *cur = pacf_all_nodes;
	  PACF_Node *node;

	  while ((node = (PACF_Node *)XP_ListNextObject(cur)) != NULL) {
	      if (node->type == type &&
		  ((!node->addr && !addr) ||
		   ( node->addr &&  addr  && !strcmp(node->addr, addr))))
		{
		    return node;
		}
	  }

	  node = PR_NEWZAP(PACF_Node);
      if (node) {
	      node->type = type;
	      node->addr = PL_strdup(addr);

	      XP_ListAddObject(pacf_all_nodes, node);
      }

	  return node;
      }
}

/* Called by netlib when it notices that a proxy is down. */
PRIVATE PACF_Node * pacf_proxy_is_down(MWContext *context,
				       char *proxy_addr,
				       u_long socks_addr,
				       short socks_port) {
    XP_List *cur = pacf_all_nodes;
    PACF_Node *node;

    while ((node = (PACF_Node *)XP_ListNextObject(cur)) != NULL) {
	if ((proxy_addr && node->addr && !PL_strcmp(node->addr, proxy_addr)) ||
	    (socks_addr &&
	     node->socks_addr == socks_addr &&
	     node->socks_port == socks_port))
	  {
	      time_t now = time(NULL);

	      if (!node->down_since) {

		  node->down_since = now;
	      }
	      node->last_try = now;
	      node->retrying = (time_t)0;
	      return node;
	  }
    }
    return NULL;
}

PRIVATE Bool fill_return_values(PACF_Type   type,
				PACF_Node * node,
				char **     ret_proxy_addr,
				u_long *    ret_socks_addr,
				short *     ret_socks_port) {
    *ret_proxy_addr = NULL;
    *ret_socks_addr = 0;
    *ret_socks_port = 0;

	if(!node)
		return FALSE;

    if (type == PACF_TYPE_PROXY) {
	*ret_proxy_addr = node->addr;
    }
    else if (!node->socks_addr) {
	char *p, *host = NULL;

	StrAllocCopy(host, node->addr);
	p = PL_strchr(host, ':');
	if (p) {
	    *p++ = '\0';
	    node->socks_port = (short)atoi(p);
	}
	else {
	    node->socks_port = 1080;
	}

	if (isdigit(*host)) {
	    /*
	     * Some systems return a number instead of a struct
	     */
	    node->socks_addr = inet_addr(host);
	}
	else {
		PRStatus rv;
	    PRHostEnt  *hp;
	    PRHostEnt  hpbuf;
	    char dbbuf[PR_NETDB_BUF_SIZE];

	    NET_InGetHostByName++; /* global semaphore */
	    rv = PR_GetHostByName(host, dbbuf, sizeof(dbbuf),  &hpbuf);
	    hp = (rv == PR_SUCCESS ? &hpbuf : NULL);
	    NET_InGetHostByName--; /* global semaphore */

	    if (!hp)
		return FALSE;  /* Fail? */

	    memcpy(&node->socks_addr, hp->h_addr, hp->h_length);
	}
    }

    *ret_socks_addr = node->socks_addr;
    *ret_socks_port = node->socks_port;
    return TRUE;
}

/* NET_SetNoProxyFailover
 * Sets a flag that indicates that proxy failover should not
 * be done.  This is used by the Enterprise Kit code, where
 * the customer might configure the client to use specific
 * proxies.  In these cases, failover can cause different
 * proxies, or no proxies to be used. */
PUBLIC void
NET_SetNoProxyFailover(void) {
  pacf_do_failover = FALSE;
}

PUBLIC PRBool
NET_LoadingPac(void) {
	return pacf_loading;
}

#ifdef MOZILLA_CLIENT
/*
 * NET_GetNoProxyFailover
 */
MODULE_PRIVATE Bool
NET_GetNoProxyFailover(void) {
  return ( pacf_do_failover == FALSE );
}
#endif /* MOZILLA_CLIENT */

/* Called by netlib to get a single string of "host:port" format,
 * given the string of possibilities returned by the Mocha script.
 *
 * This function will return an address to a proxy that is (to its
 * knowledge) up and running.  Netlib can later inform this module
 * using the function pacf_proxy_is_down() that a proxy is down
 * and should not be called for a few minutes.
 *
 * Returns FALSE if everything has failed, and an error should be
 * displayed to the user.
 *
 * Returns TRUE if there is hope.
 * If *ret is NULL, a direct connection should be attempted.
 * If *ret is not null, it is the proxy address to use. */
MODULE_PRIVATE Bool
pacf_get_proxy_addr(MWContext *context, char *list, char **ret_proxy_addr,
		    u_long *ret_socks_addr, short *ret_socks_port) {
    Bool rv = FALSE;
    char *my_copy, *cur, *p, *addr;
    PACF_Type type = PACF_TYPE_INVALID;
    PACF_Node *node;
    PACF_Node *sm_ptr = NULL;
    PACF_Node *went_down = NULL;
    time_t now = time(NULL);
    time_t smallest = (time_t)0;
    int proxy_cnt = 0;
    int socks_cnt = 0;
    int retry_now = 0;

    if (!list || !*list || !ret_proxy_addr || !ret_socks_addr || !ret_socks_port)
	return FALSE;

    if (*ret_proxy_addr || *ret_socks_addr) {
	/*
	 * We get called here because this proxy/SOCKS server was down.
	 */
	went_down = pacf_proxy_is_down(context, *ret_proxy_addr,
				       *ret_socks_addr, *ret_socks_port);
    }

    *ret_proxy_addr = NULL;
    *ret_socks_addr = 0;
    *ret_socks_port = 0;

    cur = my_copy = PL_strdup(list);

    TRACEMSG(("Getting proxy addr from config list: %s", list));

	do {
	    p = PL_strchr(cur, ';');
		if (p) {
		    do {
				*p++ = '\0';
		} while (*p && NET_IS_SPACE(*p));
		}

		for (addr=cur; *addr && !NET_IS_SPACE(*addr); addr++)
			;
		if (*addr) {
		    do {
			*addr++ = '\0';
		    } while (*addr &&  NET_IS_SPACE(*addr));
		}

		type = ((!PL_strcasecmp(cur, "DIRECT")) ? PACF_TYPE_DIRECT  :
			(!PL_strcasecmp(cur, "PROXY"))  ? PACF_TYPE_PROXY   :
			(!PL_strcasecmp(cur, "SOCKS"))  ? PACF_TYPE_SOCKS   :
							PACF_TYPE_INVALID );

		if (type == PACF_TYPE_DIRECT)           /* don't use a proxy */
		  {
		      rv = TRUE;
		      break;                            /* done */
		  }
		else if (type ==  PACF_TYPE_PROXY ||    /* use a proxy or... */       
			 type ==  PACF_TYPE_SOCKS )     /* use SOCKS */
		  {
		      if (type == PACF_TYPE_PROXY)
			  proxy_cnt++;
		      else
			  socks_cnt++;

	      node = lookup_create_node(type, addr);
		      if (*addr && node) {
			  if (node->down_since && node->retrying &&
			      now - node->retrying > PACF_RETRY_OK_AFTER)
			    {
				node->down_since = node->retrying = (time_t)0;
			    }

			  if (!node->down_since)
			    {
				if (fill_return_values(type, node,
						       ret_proxy_addr,
						       ret_socks_addr,
						       ret_socks_port))
				  {
				      rv = TRUE;
				      break;
				  }
			    }
			  else if (now - node->last_try >
				   (node->retries + 1) * PACF_AUTO_RETRY_AFTER)
			    {
				node->retries++;
				if (fill_return_values(type, node,
						       ret_proxy_addr,
						       ret_socks_addr,
						       ret_socks_port))
				  {
				      node->retrying = now;
				      rv = TRUE;
				      break;
				  }
			    }
			  else if (node != went_down &&
				   (!smallest || smallest > node->last_try))
			    {
				smallest = node->last_try;
				sm_ptr = node;
			    }
		      }
		  }
		else                                    /* invalid entry */
		  {
		    char *key = NULL;

		    if (!pacf_bad_keywords)
			{
			    pacf_bad_keywords = XP_ListNew();
			}
		    else
			{
			    XP_List *ptr = pacf_bad_keywords;

			    while ((key = (char *)XP_ListNextObject(ptr)) != NULL) {
				if (!strcmp(key, cur))
				    break;
			    }
			}

		      if (!key && XP_ListCount(pacf_bad_keywords) < 3)
			{
			    key = PL_strdup(cur);
			    XP_ListAddObject(pacf_bad_keywords, key);
			    alert2(context, XP_GetString(XP_BAD_KEYWORD_IN_PROXY_AUTOCFG), cur);
			}
		  }

		cur = p;

	    } while (cur && *cur);

    PR_Free(my_copy);

    if (rv)
	  return TRUE;

	/* If we didn't return just above here, and we're using a pad pac file,
	 * something went wrong with it so disable it for this session and return
	 * true so we go direct. */
	if(NET_UsingPadPac()) {
		net_UsePadPac(FALSE);
		return TRUE;
	}

    if (pacf_do_failover && pacf_direct_until) {
	  if (now < pacf_direct_until)
	    {
		return TRUE;
	    }
	  else if (!FE_Confirm(context,
			       !socks_cnt ? XP_GetString(XP_RETRY_AGAIN_PROXY) :
			       !proxy_cnt ? XP_GetString(XP_RETRY_AGAIN_SOCKS) : XP_GetString(XP_RETRY_AGAIN_PROXY_OR_SOCKS)))
	    {
		pacf_direct_until = now + (++pacf_direct_cnt) * PACF_DIRECT_INTERVAL;
		return TRUE;
	    }
	  else
	    {
		pacf_direct_until = (time_t)0;
		retry_now = 1;
	    }
	}

    if (smallest &&
	(retry_now ||
	 now - smallest > PACF_MIN_RETRY_AFTER ||
	 (sm_ptr && !sm_ptr->retrying &&
	  now - smallest > PACF_MIN_RETRY_ASK &&
	  confirm2(context,
		   (!socks_cnt && proxy_cnt==1 ? XP_GetString(XP_PROXY_UNAVAILABLE_TRY_AGAIN) :
		    !socks_cnt && proxy_cnt >1 ? XP_GetString(XP_ALL_PROXIES_DOWN_TRY_AGAIN) :
		    !proxy_cnt                 ? XP_GetString(XP_ALL_SOCKS_DOWN) :
						 XP_GetString(XP_ALL_DOWN_MIX)),
		   sm_ptr->addr))) &&
	fill_return_values(type, sm_ptr,
			   ret_proxy_addr, ret_socks_addr, ret_socks_port))
      {
	  sm_ptr->retrying = now;
	  sm_ptr->retries++;
	  return TRUE;
      }
    else if (pacf_do_failover && FE_Confirm(context,
			!pacf_direct_cnt ?
			(!socks_cnt ? XP_GetString(XP_OVERRIDE_PROXY) :
			 !proxy_cnt ? XP_GetString(XP_OVERRIDE_SOCKS) : XP_GetString(XP_OVERRIDE_MIX)) :
			(!socks_cnt ? XP_GetString(XP_STILL_OVERRIDE_PROXY) :
			 !proxy_cnt ? XP_GetString(XP_STILL_OVERRIDE_SOCKS) : XP_GetString(XP_STILL_OVERRIDE_SOCKS))))
      {
	  pacf_direct_until = now + (++pacf_direct_cnt) * PACF_DIRECT_INTERVAL;
	  return TRUE;
      }
    else
      {
	  return FALSE;
      }
}



/* Saves out the proxy autoconfig file to disk, in case the server
 * is down the next time.
 *
 * Returns 0 on success, -1 on failure. */
PRIVATE int pacf_save_config(void) {
    XP_File fp;
	int32 len = 0;

    if (!pacf_do_failover || !pacf_src_buf || !*pacf_src_buf || pacf_src_len <= 0)
	return -1;

    if(!(fp = NET_XP_FileOpen("", xpProxyConfig, XP_FILE_WRITE)))
	return -1;

    len = NET_XP_FileWrite(pacf_src_buf, pacf_src_len, fp);
    NET_XP_FileClose(fp);
	if (len != pacf_src_len)
		return -1;

    return 0;
}

/* Reads the proxy autoconfig file from disk.
 * This is called if the config server is not responding.
 *
 * returns 0 on success -1 on failure. */
PRIVATE int pacf_read_config(void) {
    XP_StatStruct st;
    XP_File fp;

    if (NET_XP_Stat("", &st, xpProxyConfig) == -1)
	return -1;

    if (!(fp = NET_XP_FileOpen("", xpProxyConfig, XP_FILE_READ)))
	return -1;

    pacf_src_len = st.st_size;
    pacf_src_buf = (char *)PR_Malloc(pacf_src_len + 1);
    if (!pacf_src_buf) {
	NET_XP_FileClose(fp);
	pacf_src_len = 0;
	return -1;
    }

    if ((pacf_src_len = NET_XP_FileRead(pacf_src_buf, pacf_src_len, fp)) > 0)
      {
	  pacf_src_buf[pacf_src_len] = '\0';
      }
    else
      {
	  PR_Free(pacf_src_buf);
	  pacf_src_buf = NULL;
	  pacf_src_len = 0;
      }

    NET_XP_FileClose(fp);

    return 0;
}

/* Private stream object methods for receiving the proxy autoconfig file. */
PRIVATE int pacf_write(NET_StreamClass *stream, CONST char *buf, int32 len) {
	PACF_Object *obj=stream->data_object;	
    if (len > 0) {
	if (!pacf_src_buf)
	    pacf_src_buf = (char*)PR_Malloc(len + 1);
	else
	    pacf_src_buf = (char*)PR_Realloc(pacf_src_buf,
					     pacf_src_len + len + 1);

	if (!pacf_src_buf) {    /* Out of memory */
	    pacf_src_len = 0;
	    return MK_DATA_LOADED;
	}

	memcpy(pacf_src_buf + pacf_src_len, buf, len);
	pacf_src_len += len;
	pacf_src_buf[pacf_src_len] = '\0';
    }
    return MK_DATA_LOADED;
}

PRIVATE unsigned int pacf_write_ready(NET_StreamClass *stream) {	
    return MAX_WRITE_READY;
}

PUBLIC XP_Bool
NET_InitPacfContext(void)
{
	XP_Bool first_time = TRUE;

	if ( first_time == FALSE ) return TRUE;

    if ( (PREF_OK != PREF_GetConfigContext(&configContext))
       ||(PREF_OK != PREF_GetGlobalConfigObject(&globalConfig)) )
       return FALSE;

	JS_BeginRequest(configContext);

	proxyConfig = JS_DefineObject(configContext, globalConfig, 
						"ProxyConfig",
						&pc_class, 
						NULL, 
						JSPROP_ENUMERATE);
	if (proxyConfig) {
		if (!JS_DefineProperties(configContext,
					 proxyConfig,
					 pc_props)) {
		JS_EndRequest(configContext);
		return FALSE;
		}

		if (!JS_DefineFunctions(configContext,
					proxyConfig,
					pc_methods)) {
		JS_EndRequest(configContext);
		return FALSE;
		}

	}

	JS_DefineObject(configContext, proxyConfig, 
					"bindings",
					&pc_class, 
					NULL, 
					0);

	JS_EndRequest(configContext);

	first_time = FALSE;

	return TRUE;
}

PRIVATE void pacf_complete(NET_StreamClass *stream) {
    PACF_Object *obj=stream->data_object;
	jsval result;
    XP_StatStruct st;
    JSBool ok;	

retry:
    if (!obj->flag || obj->flag == 2) {
		pacf_loading = FALSE;
		if ( !NET_InitPacfContext() ) return;
	}

    if (!pacf_src_buf) {
	if ( pacf_do_failover == FALSE && !NET_UsingPadPac() ) {
	  /* Don't failover to using no proxies */
	     FE_Alert(obj->context, XP_GetString(XP_NO_CONFIG_RECEIVED_NO_FAILOVER));
	}
	else if (obj->flag != 2 && (NET_XP_Stat("", &st, xpProxyConfig) == -1) && !NET_UsingPadPac())
	  {
			FE_Alert(obj->context, XP_GetString(XP_NO_CONFIG_RECIEVED));
	  }
	else
	{
		if(NET_UsingPadPac()) {
			pacf_read_config();
			obj->flag = 1;
			goto retry;
		} else if (obj->flag == 2 ||
			confirm2(obj->context, XP_GetString(XP_EMPTY_CONFIG_USE_PREV), pacf_url)) {
			pacf_read_config();
			obj->flag = 1;
			goto retry;
		}
	}
	pacf_ok = FALSE;
	goto out;
    }

		JS_BeginRequest(configContext);
		ok = JS_EvaluateScript(configContext, proxyConfig, 
			   pacf_src_buf, pacf_src_len, pacf_url, 0,
			   &result);
		JS_EndRequest(configContext);

    if (!ok) {
		/* Something went wrong with the js evaluation. If we're using a
		 * proxy auto-discovery pac file, don't use it again. */
		if(NET_UsingPadPac()) {
			net_UsePadPac(FALSE);
			goto out;
		}
		if (obj->flag) {
				FE_Alert(obj->context, XP_GetString(XP_EVEN_SAVED_IS_BAD));
		} else if (NET_XP_Stat("", &st, xpProxyConfig) == -1) {
				alert2(obj->context, XP_GetString(XP_BAD_CONFIG_IGNORED), pacf_url);
		} else if (confirm2(obj->context, XP_GetString(XP_BAD_CONFIG_USE_PREV), pacf_url)) {
			  PR_Free(pacf_src_buf);
			  pacf_src_buf = NULL;
			  pacf_src_len = 0;
			  pacf_read_config();
			  obj->flag = 1;            /* Uh (this is a horrid hack) */
			  goto retry;
		}
		pacf_ok = FALSE;
		} else {
		pacf_ok = TRUE;
		if (!obj->flag) {
			pacf_save_config();
		}
    }

    PR_Free(obj);

out:
	;
}

PRIVATE void pacf_abort(NET_StreamClass *stream, int status) {
	PACF_Object *obj=stream->data_object;	
    pacf_loading = FALSE;
		FE_Alert(obj->context, XP_GetString(XP_GLOBAL_CONFIG_LOAD_ABORTED));
    PR_Free(obj);
}


/* A stream constructor function for application/x-ns-proxy-autoconfig. 
 * This is used by cvmime.c; it's registered as the stream converter for
 * pac files. */
MODULE_PRIVATE NET_StreamClass *
NET_ProxyAutoConfig(int fmt, void *data_obj, URL_Struct *URL_s, 
					MWContext *w) {
    PACF_Object         *obj;
    NET_StreamClass     *stream;

    if (!pacf_loading) {
	/*
	 * The Navigator didn't start this config retrieve
	 * intentionally.  Discarding the config.
	 */
	if(!URL_s)
		return NULL;
	alert2(w, XP_GetString(XP_CONFIG_BLAST_WARNING), URL_s->address);
	return NULL;
    }
    else {
	NET_Progress(w, XP_GetString( XP_RECEIVING_PROXY_AUTOCFG ) ); 
    }

    if (pacf_src_buf) {
	PR_Free(pacf_src_buf);
	pacf_src_buf = NULL;
	pacf_src_len = 0;
    }

    if (!(stream = PR_NEWZAP(NET_StreamClass)))
	return NULL;

    if (!(obj = PR_NEWZAP(PACF_Object))) {
	PR_Free(stream);
	return NULL;
    }

    obj->context = w;

    stream->data_object         = obj;
    stream->name                = "ProxyAutoConfigLoader";
    stream->complete            = (MKStreamCompleteFunc)  pacf_complete;
    stream->abort               = (MKStreamAbortFunc)     pacf_abort;
    stream->put_block           = (MKStreamWriteFunc)     pacf_write;
    stream->is_write_ready      = (MKStreamWriteReadyFunc)pacf_write_ready;
    stream->window_id           = w;

    return stream;
}



/* calls NET_GetURL() to get the url that had been queued up behind the 
 * actual pac file url. */
static void pacf_restart_queued(URL_Struct *URL_s, int status,
				MWContext *window_id) {
    XP_StatStruct st;

	/* We want to fail silently if we're loading a pad pac and fail,
	 * so fall through to bottom and load the queued url. */
    if (pacf_loading && !(NET_UsingPadPac() || foundPADPAC) ) {
	
	if ( pacf_do_failover == FALSE ) {
	  /* Don't failover to using no proxies */
	     FE_Alert(window_id, XP_GetString(XP_CONF_LOAD_FAILED_NO_FAILOVER));
	}
	else if (NET_XP_Stat("", &st, xpProxyConfig) == -1)
	  {
	      if (status < 0)
		  FE_Alert(window_id, XP_GetString(XP_CONF_LOAD_FAILED_IGNORED));
	      else {
				alert2(window_id, XP_GetString(XP_BAD_TYPE_CONFIG_IGNORED), pacf_url);
		  }
	  }
	else if (status == MK_INTERRUPTED)
	  {
		  /* silently fail and retry later */
		  NET_ProxyAcLoaded = FALSE;
		  NET_GlobalAcLoaded = FALSE;
	  }
	else if (status < 0
		 ? FE_Confirm(window_id, XP_GetString(XP_CONF_LOAD_FAILED_USE_PREV))
		 : confirm2(window_id, XP_GetString(XP_BAD_TYPE_USE_PREV), pacf_url))
	  {
	      PACF_Object *obj = PR_NEWZAP(PACF_Object);
		  NET_StreamClass stream;
		  stream.data_object=obj;

	      if (obj) {
		  obj->context = window_id;
		  obj->flag = 2;
		  pacf_complete(&stream);
	      }
	  }

	pacf_loading = FALSE;
    } else {
		/* Call this only if everything succeeded -- otherwise
		   the netlib has already freed the URL_s, and there isn't
		   a clean fix, so for now we'll just forget the URL load
		   if proxy config load went foul.
		 */
		if(queued_state) {
			NET_GetURL(queued_state->URL_s,
				   queued_state->output_format,
				   queued_state->window_id,
				   queued_state->exit_routine);
		}
	}
	PR_FREEIF(queued_state);
	queued_state = NULL;
}



/* Called by mkgeturl.c to originally retrieve, and re-retrieve
 * the proxy autoconfig file.
 *
 * autoconfig_url is the URL pointing to the autoconfig.
 *
 * The rest of the parameters are what was passed to NET_GetURL(),
 * and when the autoconfig load finishes NET_GetURL() will be called
 * with those exact same parameters.
 *
 * This is because the proxy config is loaded when NET_GetURL() is
 * called for the very first time, and the actual request must be put
 * on hold when the proxy config is being loaded.
 *
 * When called from the explicit proxy config RE-load function
 * NET_ReloadProxyConfig, the four last parameters are all zero,
 * and no request gets restarted. */
MODULE_PRIVATE int NET_LoadProxyConfig(char *autoconf_url,
				       URL_Struct *URL_s,
				       FO_Present_Types output_format,
				       MWContext *window_id,
				       Net_GetUrlExitFunc *exit_routine) {
    URL_Struct *my_url_s = NULL;
	char * global_url = NULL;

    if (!autoconf_url)
	return -1;

	if (!PL_strcmp(autoconf_url,"BAD-NOAUTOADMNLIB")) {
	    FE_Alert(window_id, XP_GetString( XP_AUTOADMIN_MISSING ));
		return -1;
	}

    StrAllocCopy(pacf_url, autoconf_url);
    my_url_s = NET_CreateURLStruct(autoconf_url, NET_SUPER_RELOAD);

    
	if (exit_routine) {

	queued_state = PR_NEWZAP(PACF_QueuedState);
	if(!queued_state)
		return -1;
	queued_state->URL_s = URL_s;
	queued_state->output_format = output_format;
	queued_state->window_id = window_id;
	queued_state->exit_routine = exit_routine;

	if(!my_url_s)
		return -1;

	my_url_s->pre_exit_fn = pacf_restart_queued;
    }

    /* Alert the proxy autoconfig module that config is coming */
    pacf_loading = TRUE;
    pacf_find_proxy_undefined = FALSE;

    return NET_GetURL(my_url_s, FO_PRESENT, window_id, NULL);
}

/* Returns a pointer to a NULL-terminted buffer which contains
 * the text of the proxy autoconfig file. */
PUBLIC char * NET_GetProxyConfigSource(void) {

    return pacf_src_buf;

}


 /* Given a URL, returns the proxy that should be used.
 * The proxy is determined by the proxy autoconfig file,
 * which is a JavaScript routine. */
MODULE_PRIVATE char *pacf_find_proxies_for_url(MWContext *context, 
											   URL_Struct *URL_s ) {
    jsval rv;
    char *buf = NULL;
    char *host = NULL;
    char *p, *q, *r;
    int i, len = 0;
    char *safe_url = NULL;
    char *orig_url = NULL;
    char *method = NULL;
    char *bad_url = NULL;
    char *result = NULL;
    JSBool ok;

	if(!URL_s)
		return NULL;

	orig_url=URL_s->address;
	method=mkMethodString(URL_s->method);

    /* If proxy failover is not allowed, and we weren't
     * able to autoload the proxy, return a string that
     * pacf_get_proxy_addr will always fail with. */
    if ( !pacf_do_failover && !pacf_loading && !pacf_ok && !NET_FindProxyInJSC()) {
      return "";
    }

    if ( !NET_FindProxyInJSC() && (!orig_url || !pacf_ok || pacf_loading || pacf_find_proxy_undefined))
	return NULL;

    if (!(bad_url = PL_strdup(orig_url)))
	goto out;

    len = NET_UnEscapeCnt(bad_url);

    if (!(safe_url = PR_Malloc(2 * len + 1)))    /* worst case */
	goto out;

    p = bad_url;
    q = safe_url;
    for(i=0; i<len; i++, p++) {
	switch (*p) {
	  case '\n':
	    *q++ = '\\';
	    *q++ = 'n';
	    break;
	  case '\r':
	    *q++ = '\\';
	    *q++ = 'r';
	    break;
	  case '\0':
	    *q++ = '\\';
	    *q++ = '0';
	    break;
	  case '"':
	    *q++ = '\\';
	    *q++ = '"';
	    break;
	  case '\\':
	    *q++ = '\\';
	    *q++ = '\\';
	    break;
	  default:
	    *q++ = *p;
	}
    }
    *q = '\0';

    len  = (int)(q - safe_url);

    if (!(host = PR_Malloc(len + 1)))
	goto out;

    if (!(buf  = PR_Malloc(len*2 + 50)))
	goto out;

    host[0] = '\0';

    p = PL_strstr(safe_url, "://");
    if (p) {
	p += 3;
	q = PL_strchr(p, '/');
	if (q)
	    *q = '\0';
	r = PL_strchr(p, '@');
	if (r)
		p = r + 1;
	PL_strcpy(host, p);
	if (q)
	    *q = '/';
	p = PL_strchr(host, ':');
	if (p)
	    *p = '\0';
    }

	if ( NET_FindProxyInJSC() ) {
	    XP_SPRINTF(buf, "ProxyConfig.FindProxyForURL(\"%s\",\"%s\",\"%s\")", safe_url, host,
	       method ? method : "" );
	} else {
	    XP_SPRINTF(buf, "FindProxyForURL(\"%s\",\"%s\",\"%s\")", safe_url, host,
	       method ? method : "" );
	}

    JS_BeginRequest(configContext);
    if (!JS_AddRoot(configContext, &rv))  {
	JS_EndRequest(configContext);
	goto out;
    }

	if ( NET_FindProxyInJSC() ) {
		ok = JS_EvaluateScript(configContext, globalConfig,
			   buf, strlen(buf), 0, 0, &rv);
	} else {
		ok = JS_EvaluateScript(configContext, proxyConfig,
			   buf, strlen(buf), 0, 0, &rv);
	}

    if (ok) {
	if (JSVAL_IS_STRING(rv)) {
	    const char *name =
		JS_GetStringBytes(JSVAL_TO_STRING(rv));
	    if (*name)
		result = PL_strdup(name);
	}
    }

    JS_RemoveRoot(configContext, &rv);
    JS_EndRequest(configContext);
out:
    FREEIF(method);
    FREEIF(buf);
    FREEIF(host);
    FREEIF(safe_url);
    FREEIF(bad_url);
    return result;

}


/* Utility functions to be called from Javascript (aka Mocha).
 * These are the actual implementations of the javascript fucntions that
 * are in the javascript pac file.
 *
 * Get the number of DNS domain levels (number of dots):
 *
 *      dnsDomainLevels(host)
 *
 *
 * Host/URL based conditions:
 *
 *      isPlainHostName(host)
 *      dnsDomainIs(host, name)
 *      localHostOrDomainIs(host, name)
 *      isResolvable(host)
 *      regExpMatch(host or URL, regexp)
 *
 *
 * Date/time based conditions (limits inclusive):
 *
 *      weekdayRange(wkday)
 *      weekdayRange(wkday, wkday)
 *
 *      dateRange(day)
 *      dateRange(day, day)
 *      dateRange(mon)
 *      dateRange(mon, mon)
 *      dateRange(year)
 *      dateRange(year, year)
 *      dateRange(day, mon, day, mon)
 *      dateRange(mon, year, mon, year)
 *      dateRange(day, mon, year, day, mon, year)
 *
 *      timeRange(hour)
 *      timeRange(hour, hour)
 *      timeRange(hour, min, hour, min)
 *      timeRange(hour, min, sec, hour, min, sec)
 *
 *
 *
 */

/* Returns true if the hostname doesn't contain a dot
 * (is a plain hostname, not an FQDN).
 *
 * Just a string operation, doesn't consult DNS. */
MODULE_PRIVATE JSBool PR_CALLBACK
proxy_isPlainHostName(JSContext *mc, JSObject *obj, unsigned int argc, 
					  jsval *argv, jsval *rval) {
    if (argc >= 1 && JSVAL_IS_STRING(argv[0])) {
	const char *h = JS_GetStringBytes(JSVAL_TO_STRING(argv[0]));

	if (h && !PL_strchr(h, '.')) {
	    *rval = JSVAL_TRUE;
	    return JS_TRUE;
	}
    }

    *rval = JSVAL_FALSE;
    return JS_TRUE;
}

/* Returns the number of domain levels in the hostname
 * (the number of dots, actually).
 *
 * Just a string operation, doesn't consult DNS. */
MODULE_PRIVATE JSBool PR_CALLBACK
proxy_dnsDomainLevels(JSContext *mc, JSObject *obj, unsigned int argc, 
					  jsval *argv, jsval *rval) {
    int i = 0;

    if (argc >= 1 && JSVAL_IS_STRING(argv[0])) {
	const char *h = JS_GetStringBytes(JSVAL_TO_STRING(argv[0]));

	if (h) {
	    while (*h) {
		if (*h == '.')
		    i++;
		h++;
	    }
	}
    }

    *rval = INT_TO_JSVAL(i);
    return JS_TRUE;
}

/* Checks if the hostname contains the given domain. */
MODULE_PRIVATE JSBool PR_CALLBACK
proxy_dnsDomainIs(JSContext *mc, JSObject *obj, unsigned int argc, 
				  jsval *argv, jsval *rval) {
    if (argc >= 2 && JSVAL_IS_STRING(argv[0]) && JSVAL_IS_STRING(argv[1])) {
	const char *h = JS_GetStringBytes(JSVAL_TO_STRING(argv[0]));
	const char *p = JS_GetStringBytes(JSVAL_TO_STRING(argv[1]));
	int len1, len2;

	if (h && p && (len1 = PL_strlen(h)) >= (len2 = PL_strlen(p)) &&
	    (!PL_strcasecmp(h + len1 - len2, p))) {
	    *rval = JSVAL_TRUE;
	    return JS_TRUE;
	}
    }

    *rval = JSVAL_FALSE;
    return JS_TRUE;
}

/* Returns true if the hostname matches exactly the given
 * pattern hostname, or if the hostname is just a local hostname
 * and it matches the hostname in the pattern FQDN hostname. */
MODULE_PRIVATE JSBool PR_CALLBACK
proxy_localHostOrDomainIs(JSContext *mc, JSObject *obj, unsigned int argc, 
						  jsval *argv, jsval *rval) {
    if (argc >= 2 && JSVAL_IS_STRING(argv[0]) && JSVAL_IS_STRING(argv[1])) {
	const char *h = JS_GetStringBytes(JSVAL_TO_STRING(argv[0]));
	const char *p = JS_GetStringBytes(JSVAL_TO_STRING(argv[1]));
	char *hp, *pp;

	if (h && p) {
	    hp = PL_strchr(h, '.');
	    pp = PL_strchr(p, '.');

	    if (hp || !pp) {
		if (!PL_strcasecmp(h,p)) {
		    *rval = JSVAL_TRUE;
		    return JS_TRUE;
		}
	    }
	    else if (!PL_strncasecmp(h, p, pp - p)) {
		*rval = JSVAL_TRUE;
		return JS_TRUE;
	    }
	}
    }

    *rval = JSVAL_FALSE;
    return JS_TRUE;
}

/* Attempts to resolve the DNS name, and returns TRUE if resolvable. */
MODULE_PRIVATE JSBool PR_CALLBACK
proxy_isResolvable(JSContext *mc, JSObject *obj, unsigned int argc, 
				   jsval *argv, jsval *rval) {
    if (argc >= 1 && JSVAL_IS_STRING(argv[0])) {
	const char *h = JS_GetStringBytes(JSVAL_TO_STRING(argv[0]));
	PRHostEnt *hp = NULL;
	PRStatus rv;
    PRHostEnt hpbuf;
    char dbbuf[PR_NETDB_BUF_SIZE];

	if (h) {
	    char *safe = PL_strdup(h);
	    if (PL_strlen(safe) > 64)
		safe[64] = '\0';
	    rv = PR_GetHostByName(safe, dbbuf, sizeof(dbbuf),  &hpbuf);
	    hp = (rv == PR_SUCCESS ? &hpbuf : NULL);
	    PR_Free(safe);
	}

	if (hp) {
	    TRACEMSG(("~~~~~~~~~~~ isResolvable(%s) returns TRUE\n", h));
	    TRACEMSG(("~~~~~~~~~~~ hp = %p, hp->h_name = %s\n", hp, hp->h_name ? hp->h_name : "(null)"));
	    *rval = JSVAL_TRUE;
	    return JS_TRUE;
	}
    }

    TRACEMSG(("~~~~~~~~~~~ isResolvable(%s) returns FALSE\n", argv[0]));
    *rval = JSVAL_FALSE;
    return JS_TRUE;
}

/* Resolves a DNS name, and returns the IP address string.
 *
 * Maintains a private cache for the last resolved address (so this
 * function can be called multiple times with the same host argument
 * without doing actual DNS queries every time). */
PRIVATE char *proxy_dns_resolve(const char *host) {
    static char *cache_host = NULL;
    static char *cache_ip = NULL;
	PRStatus rv;
    PRHostEnt *hp = NULL;
    PRHostEnt hpbuf;
    char dbbuf[PR_NETDB_BUF_SIZE];

    if (host) {
	const char *p;
	char *safe = NULL;
	XP_Bool is_numeric_ip = TRUE;

	for(p=host; *p; p++) {
	    if (!NET_IS_DIGIT(*p) && *p != '.') {
		is_numeric_ip = FALSE;
		break;
	    }
	}
	if (is_numeric_ip) {
	    return PL_strdup(host);
	}

	if (cache_host && cache_ip && !PL_strcmp(cache_host, host)) {
	    return PL_strdup(cache_ip);
	}
	safe = PL_strdup(host);
	if (safe) {
	    if (PL_strlen(safe) > 64)
		safe[64] = '\0';

	    rv = PR_GetHostByName(safe, dbbuf, sizeof(dbbuf),  &hpbuf);
	    hp = (rv == PR_SUCCESS ? &hpbuf : NULL);

	    PR_Free(safe);
	}
	if (hp) {
	    char *ip = NULL;
	    struct in_addr in;

	    memcpy(&in.s_addr, hp->h_addr, hp->h_length);

	    ip = inet_ntoa(in);
	    if (ip) {
		StrAllocCopy(cache_host, host);
		StrAllocCopy(cache_ip, ip);

		return PL_strdup(ip);
	    }
	}
    }

    return NULL;
}

MODULE_PRIVATE JSBool PR_CALLBACK
proxy_dnsResolve(JSContext *mc, JSObject *obj, unsigned int argc, 
				 jsval *argv, jsval *rval) {
    if (argc >= 1 && JSVAL_IS_STRING(argv[0])) {
	const char *host = JS_GetStringBytes(JSVAL_TO_STRING(argv[0]));
	char *ip = proxy_dns_resolve(host);

	if (ip) {
	    JSString * str = JS_NewString(mc, ip, strlen(ip));
	    if (!str) {
		PR_Free(ip);
		return JS_FALSE;
	    }
	    *rval = STRING_TO_JSVAL(str);
	    return JS_TRUE;
	}
    }

    *rval = JSVAL_NULL;
    return JS_TRUE;
}

/* Returns the IP address of the host machine as a string. */
MODULE_PRIVATE JSBool PR_CALLBACK
proxy_myIpAddress(JSContext *mc, JSObject *obj, unsigned int argc, 
				  jsval *argv, jsval *rval) {
    static XP_Bool initialized = FALSE;
    static char *my_address = NULL;

    if (!initialized) {
	char name[100];

	initialized = TRUE;
	if (PR_GetSystemInfo(PR_SI_HOSTNAME, name, sizeof(name)) == PR_SUCCESS) {
	    my_address = proxy_dns_resolve(name);
	}
    }

    TRACEMSG(("~~~~~~~~~~~~~~~~~~ myIpAddress() returns %s\n", my_address ? my_address : "(null)"));

    if (my_address) {
        JSString *str;
	str = JS_NewStringCopyZ(mc, my_address);
	if (!str)
	    return JS_FALSE;
	*rval = STRING_TO_JSVAL(str);
	return JS_TRUE;
    }

    *rval = JSVAL_NULL;
    return JS_TRUE;
}

/* Determines if the host IP address belongs to the given network.
 * Uses SOCKS style address pattern and mask:
 *
 *      isInNet(hostname, "111.222.33.0", "255.255.255.0"); */
PRIVATE unsigned long convert_addr(const char *ip) {
    char *p, *q, *buf = NULL;
    int i;
    unsigned char b[4];
    unsigned long addr = 0L;

	p = buf = PL_strdup(ip);
    if (ip && p) {
	for(i=0; p && i<4; i++) {
	    q = PL_strchr(p, '.');
	    if (q) {
		*q = '\0';
	    }
	    b[i] = XP_ATOI(p) & 0xff;
	    if (q) {
		p = q+1;
	    }
	}
	addr = (((unsigned long)b[0] << 24) |
		((unsigned long)b[1] << 16) |
		((unsigned long)b[2] <<  8) |
		((unsigned long)b[3]));

	PR_Free(buf);
    }

    return htonl(addr);
}

MODULE_PRIVATE JSBool PR_CALLBACK
proxy_isInNet(JSContext *mc, JSObject *obj, unsigned int argc, 
			  jsval *argv, jsval *rval) {
    if (argc >= 3 &&
	JSVAL_IS_STRING(argv[0]) &&
	JSVAL_IS_STRING(argv[1]) &&
	JSVAL_IS_STRING(argv[2]))
      {
	  const char *ipstr = JS_GetStringBytes(JSVAL_TO_STRING(argv[0]));
	  char *ip = proxy_dns_resolve(ipstr);
	  const char *patstr = JS_GetStringBytes(JSVAL_TO_STRING(argv[1]));
	  const char *maskstr = JS_GetStringBytes(JSVAL_TO_STRING(argv[2]));

	  if (ip) {
	      unsigned long host = convert_addr(ip);
	      unsigned long pat  = convert_addr(patstr);
	      unsigned long mask = convert_addr(maskstr);

	      PR_Free(ip);

	      if ((mask & host) == (mask & pat)) {
		  TRACEMSG(("~~~~~~~~~~~~ isInNet(%s(%s), %s, %s) returns TRUE\n",
			    ipstr, ip, patstr, maskstr));
		    *rval = JSVAL_TRUE;
		    return JS_TRUE;
	      }
	  }
      }

    TRACEMSG(("~~~~~~~~~~~~ isInNet() returns FALSE\n"));

    *rval = JSVAL_FALSE;
    return JS_TRUE;
}

/* Does a regular expression match between the host/URL and the pattern.
 *
 * Returns true on match. */
MODULE_PRIVATE JSBool PR_CALLBACK
proxy_regExpMatch(JSContext *mc, JSObject *obj, unsigned int argc, 
				  jsval *argv, jsval *rval) {
    if (argc >= 2 && JSVAL_IS_STRING(argv[0]) && JSVAL_IS_STRING(argv[1])) {
	const char *url = JS_GetStringBytes(JSVAL_TO_STRING(argv[0]));
	const char *pat = JS_GetStringBytes(JSVAL_TO_STRING(argv[1]));

	if (url && pat && NET_RegExpValid((char *) pat) &&       /* XXX */
	    !NET_RegExpMatch((char *) url, (char *) pat, TRUE)) {/* XXX */
	    *rval = JSVAL_TRUE;
	    return JS_TRUE;
	}
    }

    *rval = JSVAL_FALSE;
    return JS_TRUE;
}

PRIVATE
struct tm * get_struct_tm(JSContext *mc,
			  unsigned int *argc, jsval *argv) {
    time_t now = time(NULL);

    if (*argc > 0 &&  JSVAL_IS_STRING(argv[*argc-1])) {
	const char *laststr = JS_GetStringBytes(JSVAL_TO_STRING(argv[*argc-1]));
	if (!PL_strcasecmp(laststr, "GMT")) {
	    (*argc)--;
	    return gmtime(&now);
	}
    }
    return localtime(&now);
}

char *weekdays = "SUNMONTUEWEDTHUFRISAT";
char *monnames = "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC";

PRIVATE int get_no(const char *nam, char *arr) {
    char *p = PL_strcasestr(arr, nam);
    return p ? (((int)(p - arr)) / 3) : -1;
}

PRIVATE int get_em(JSContext *mc, int argc, jsval *argv,
		   int *d, int *m, int *y) {
    int i=0;

    *m = *d = *y = -1;

    for (i=0; i<argc; i++) {
	if (JSVAL_IS_STRING(argv[i])) {
	    *m = get_no(JS_GetStringBytes(JSVAL_TO_STRING(argv[i])), monnames);
	} 
	else if (JSVAL_IS_NUMBER(argv[i])) {
	    if (JSVAL_TO_INT(argv[i]) > 1900)
		*y = JSVAL_TO_INT(argv[i]) - 1900;
	    else
		*d = JSVAL_TO_INT(argv[i]);
	} 
	else {
	    assert(0);
	}
    }
    return ((*d > -1 ? 1 : 0) +
	    (*m > -1 ? 1 : 0) +
	    (*y > -1 ? 1 : 0));
}

PRIVATE int are_different(JSContext *mc, jsval *argv) {
    int d1, d2, m1, m2, y1, y2;

    get_em(mc, 1,  argv,    &d1, &m1, &y1);
    get_em(mc, 1, &argv[1], &d2, &m2, &y2);

    return ((d1 == -1 || d2 == -1) &&
	    (m1 == -1 || m2 == -1) &&
	    (y1 == -1 || y2 == -1));
}

PRIVATE long get_rel(int sel_d, int sel_m, int sel_y, int d, int m, int y) {
    return ((sel_d > -1 ? d : 0) +
	    (sel_m > -1 ? m : 0) * 31 +
	    (sel_y > -1 ? y : 0) * 372);
}

PRIVATE int cmp_properly(int sel_y, long rel_lo, long rel, long rel_hi) {
    if (sel_y || rel_lo < rel_hi)
	return rel_lo <= rel && rel <= rel_hi;
    else
	return rel_lo <= rel || rel <= rel_hi;
}

MODULE_PRIVATE JSBool PR_CALLBACK
proxy_dateRange(JSContext *mc, JSObject *obj, unsigned int argc, 
				jsval *argv, jsval *rval) {
    int d1, d2, m1, m2, y1, y2;
    struct tm *tms = get_struct_tm(mc, &argc, argv);

    d1 = d2 = m1 = m2 = y1 = y2 = -1;

    if (argc == 1 || argc == 3 || (argc==2 && are_different(mc, argv)))
      {
	  *rval = ((get_em(mc, argc, argv, &d1, &m1, &y1) &&
		   (d1 == -1 || d1 == tms->tm_mday)  &&
		   (m1 == -1 || m1 == tms->tm_mon)   &&
		   (y1 == -1 || y1 == tms->tm_year))
		  ? JSVAL_TRUE : JSVAL_FALSE);
      }
    else
      {
	  *rval = (((get_em(mc, argc/2,  argv,         &d1, &m1, &y1) ==
		     get_em(mc, argc/2, &argv[argc/2], &d2, &m2, &y2))   &&
		   cmp_properly(y1,
				get_rel(d1, m1, y1, d1, m1, y1),
				get_rel(d1, m1, y1, tms->tm_mday, tms->tm_mon, tms->tm_year),
				get_rel(d1, m1, y1, d2, m2, y2)))
		  ? JSVAL_TRUE : JSVAL_FALSE);
      }
    return JS_TRUE;
}

MODULE_PRIVATE JSBool PR_CALLBACK
proxy_weekdayRange(JSContext *mc, JSObject *obj, unsigned int argc, 
				   jsval *argv, jsval *rval) {
    struct tm *tms = get_struct_tm(mc, &argc, argv);
    int i=0, j=0;

    if (argc >= 1)
	i = get_no(JS_GetStringBytes(JSVAL_TO_STRING(argv[0])), weekdays);
    if (argc >= 2)
	j = get_no(JS_GetStringBytes(JSVAL_TO_STRING(argv[1])), weekdays);

    *rval = (((argc == 1 && i == tms->tm_wday) ||
	      (argc == 2 && ((i <= j && (i <= tms->tm_wday && j >= tms->tm_wday)) ||
			    (i >  j && (i <= tms->tm_wday || j >= tms->tm_wday)))))
	    ? JSVAL_TRUE : JSVAL_FALSE);
    return JS_TRUE;
}

/* timeRange(<hr>)
 * timeRange(<hr>, <hr>)
 * timeRange(<hr>, <min>, <hr>, <min>)
 * timeRange(<hr>, <min>, <sec>, <hr>, <min>, <sec>) */
MODULE_PRIVATE JSBool PR_CALLBACK
proxy_timeRange(JSContext *mc, JSObject *obj, unsigned int argc, 
				jsval *argv, jsval *rval) {
	int32 secondsA=0, secondsB=0, secondsC=0;
    struct tm *tms = get_struct_tm(mc, &argc, argv);

	if(argc == 1) {
		secondsA = JSVAL_TO_INT(argv[0])*60*60;
		secondsB = tms->tm_hour*60*60;
		*rval = (secondsA == secondsB) ? JSVAL_TRUE : JSVAL_FALSE;
		return JS_TRUE;
	}
	if(argc == 2) {
		secondsA = JSVAL_TO_INT(argv[0])*60*60;
		secondsB = tms->tm_hour*60*60;
		secondsC = JSVAL_TO_INT(argv[1])*60*60;
	}
	if(argc == 4) {
		secondsA = JSVAL_TO_INT(argv[0])*60*60 + JSVAL_TO_INT(argv[1])*60;
		secondsB = tms->tm_hour*60*60 + tms->tm_min*60;
		secondsC = JSVAL_TO_INT(argv[2])*60*60 + JSVAL_TO_INT(argv[3])*60;
	}
	if(argc == 6) {
		secondsA = JSVAL_TO_INT(argv[0])*60*60 + JSVAL_TO_INT(argv[1])*60 + JSVAL_TO_INT(argv[2]);
		secondsB = tms->tm_hour*60*60 + tms->tm_min*60 + tms->tm_sec;
		secondsC = JSVAL_TO_INT(argv[3])*60*60 + JSVAL_TO_INT(argv[4])*60 + JSVAL_TO_INT(argv[5]);
	}
	*rval = (secondsA <= secondsB && secondsB < secondsC) ? JSVAL_TRUE : JSVAL_FALSE;
	return JS_TRUE;
}

