home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / lib / libnet / jscookie.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  17.6 KB  |  605 lines
  1. /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18. /*
  19.    jscookie.c -- javascript reflection of cookies for filters.
  20.    Created: Frederick G.M. Roeber <roeber@netscape.com>, 12-Jul-97.
  21.    Adopted: Judson Valeski, 1997.
  22.    Large chunks of this were stolen from jsmsg.c.
  23.  */
  24.  
  25. #include "mkutils.h"
  26. #include "mkutils.h"
  27. #include "mkparse.h"
  28. #include "mkaccess.h"
  29. #include "prefapi.h"
  30. #include "jsapi.h"
  31. #include "xp_core.h"
  32. #include "xp_mcom.h"
  33. #include "jscookie.h"
  34. #include "ds.h"
  35. #include "htmldlgs.h"
  36. #include "xpgetstr.h"
  37.  
  38. extern int MK_ACCESS_JAVASCRIPT_COOKIE_FILTER;
  39.  
  40. static JSObject *filter_obj = NULL;
  41. static JSContext *filter_context = NULL;
  42.  
  43. static JSBool error_reporter_installed = JS_FALSE;
  44. static JSErrorReporter previous_error_reporter;
  45.  
  46. /* tells us when we should recompile the file. */
  47. static JSBool need_compile = JS_TRUE;
  48.  
  49. /* This is the private instance data associated with a cookie */
  50. typedef struct JSCookieData {
  51.     JSContext *js_context;
  52.     JSObject *js_object;
  53.     JSCFCookieData *data;
  54.     PRPackedBool property_changed, rejected, accepted, ask, decision_made;
  55. } JSCookieData;
  56.  
  57. /* The properties of a cookie that we reflect */
  58. enum cookie_slot {
  59.     COOKIE_PATH            = -1,
  60.     COOKIE_DOMAIN        = -2,
  61.     COOKIE_NAME            = -3,
  62.     COOKIE_VALUE        = -4,
  63.     COOKIE_EXPIRES        = -5,
  64.     COOKIE_URL            = -6,
  65.     COOKIE_IS_SECURE        = -7,
  66.     COOKIE_IS_DOMAIN        = -8,
  67.     COOKIE_PROMPT_PREF        = -9,
  68.     COOKIE_PREF            = -10
  69. };
  70.  
  71. /* 
  72.  * Should more of these be readonly? What does it mean for a cookie
  73.  *   to de secure?  -chouck
  74.  */
  75. static JSPropertySpec cookie_props[] = {
  76.     { "path",       COOKIE_PATH,        JSPROP_ENUMERATE },
  77.     { "domain",     COOKIE_DOMAIN,      JSPROP_ENUMERATE },
  78.     { "name",       COOKIE_NAME,        JSPROP_ENUMERATE },
  79.     { "value",      COOKIE_VALUE,       JSPROP_ENUMERATE },
  80.     { "expires",    COOKIE_EXPIRES,     JSPROP_ENUMERATE },
  81.     { "url",        COOKIE_URL,         JSPROP_ENUMERATE|JSPROP_READONLY },
  82.     { "isSecure",   COOKIE_IS_SECURE,   JSPROP_ENUMERATE },
  83.     { "isDomain",   COOKIE_IS_DOMAIN,   JSPROP_ENUMERATE },
  84.     { "prompt",     COOKIE_PROMPT_PREF, JSPROP_ENUMERATE|JSPROP_READONLY },
  85.     { "preference", COOKIE_PREF,        JSPROP_ENUMERATE|JSPROP_READONLY },
  86.     { 0 }
  87. };
  88.  
  89. PR_STATIC_CALLBACK(JSBool)
  90. cookie_getProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
  91. {
  92.     JSCookieData *data;
  93.     JSString *str;
  94.     jsint slot;
  95.  
  96.     data = (JSCookieData *)JS_GetPrivate(cx, obj);
  97.     if (!data)
  98.     return JS_TRUE;
  99.  
  100.     if (!JSVAL_IS_INT(id))
  101.         return JS_TRUE;
  102.  
  103.     slot = JSVAL_TO_INT(id);
  104.  
  105.     switch (slot) {
  106.     case COOKIE_PATH:
  107.         str = JS_NewStringCopyZ(cx, (const char *)data->data->path_from_header);
  108.         if( (JSString *)0 == str )
  109.             return JS_FALSE;
  110.         *vp = STRING_TO_JSVAL(str);
  111.         break;
  112.     case COOKIE_DOMAIN:
  113.         str = JS_NewStringCopyZ(cx, (const char *)data->data->host_from_header);
  114.         if( (JSString *)0 == str )
  115.             return JS_FALSE;
  116.         *vp = STRING_TO_JSVAL(str);
  117.         break;
  118.     case COOKIE_NAME:
  119.         str = JS_NewStringCopyZ(cx, (const char *)data->data->name_from_header);
  120.         if( (JSString *)0 == str )
  121.             return JS_FALSE;
  122.         *vp = STRING_TO_JSVAL(str);
  123.         break;
  124.     case COOKIE_VALUE:
  125.         str = JS_NewStringCopyZ(cx, (const char *)data->data->cookie_from_header);
  126.         if( (JSString *)0 == str )
  127.             return JS_FALSE;
  128.         *vp = STRING_TO_JSVAL(str);
  129.         break;
  130.     case COOKIE_EXPIRES:
  131.         *vp = INT_TO_JSVAL(data->data->expires);
  132.         break;
  133.     case COOKIE_URL:
  134.         str = JS_NewStringCopyZ(cx, (const char *)data->data->url);
  135.         if( (JSString *)0 == str )
  136.             return JS_FALSE;
  137.         *vp = STRING_TO_JSVAL(str);
  138.         break;
  139.     case COOKIE_IS_SECURE:
  140.         *vp = BOOLEAN_TO_JSVAL(data->data->secure);
  141.         break;
  142.     case COOKIE_IS_DOMAIN:
  143.         *vp = BOOLEAN_TO_JSVAL(data->data->domain);
  144.         break;
  145.     case COOKIE_PROMPT_PREF:
  146.         *vp = BOOLEAN_TO_JSVAL(data->data->prompt);
  147.         break;
  148.     case COOKIE_PREF:
  149.         *vp = INT_TO_JSVAL(data->data->preference);
  150.         break;
  151.     }
  152.  
  153.     return JS_TRUE;
  154. }
  155.  
  156. PR_STATIC_CALLBACK(JSBool)
  157. cookie_setProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
  158. {
  159.     JSCookieData *data;
  160.     jsint slot;
  161.     PRInt32 i;
  162.     JSBool b;
  163.  
  164.     data = (JSCookieData *)JS_GetPrivate(cx, obj);
  165.     if (!data)
  166.         return JS_TRUE;
  167.  
  168.     if (!JSVAL_IS_INT(id))
  169.         return JS_TRUE;
  170.  
  171.     slot = JSVAL_TO_INT(id);
  172.  
  173.     if (slot == COOKIE_PATH) {
  174.         data->data->path_from_header = JS_GetStringBytes(JSVAL_TO_STRING(*vp));
  175.     } 
  176.     else if (slot == COOKIE_DOMAIN) {
  177.         data->data->host_from_header = JS_GetStringBytes(JSVAL_TO_STRING(*vp));
  178.     }
  179.     else if (slot == COOKIE_NAME) {
  180.         data->data->name_from_header = JS_GetStringBytes(JSVAL_TO_STRING(*vp));
  181.     }
  182.     else if (slot == COOKIE_VALUE) {
  183.         data->data->cookie_from_header = JS_GetStringBytes(JSVAL_TO_STRING(*vp));
  184.     }
  185.     else if (slot == COOKIE_EXPIRES) {
  186.         if( !JS_ValueToInt32(cx, *vp, (long *)&i) )
  187.             return JS_FALSE;
  188.         data->data->expires = i;
  189.     }
  190.     else if (slot == COOKIE_IS_SECURE) {
  191.         if( !JS_ValueToBoolean(cx, *vp, &b) )
  192.             return JS_FALSE;
  193.         data->data->secure = b;        
  194.     }
  195.     else if (slot == COOKIE_IS_DOMAIN) {
  196.         if( !JS_ValueToBoolean(cx, *vp, &b) )
  197.             return JS_FALSE;
  198.         data->data->domain = b;        
  199.     }
  200.  
  201.     data->property_changed = TRUE;
  202.     return JS_TRUE;
  203. }
  204.  
  205. PR_STATIC_CALLBACK(void)
  206. cookie_finalize(JSContext *cx, JSObject *obj)
  207. {
  208.     JSCookieData *cookie;
  209.     cookie = JS_GetPrivate(cx, obj);
  210.     FREEIF(cookie);
  211. }
  212.  
  213. /* So we can possibly add functions "global" to filters... */
  214. static JSClass global_class = {
  215.     "CookieFilters", 0 /* no private data */,
  216.     JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
  217.     JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, JS_FinalizeStub
  218. };
  219.  
  220. static JSClass js_cookie_class = {
  221.     "Cookie", JSCLASS_HAS_PRIVATE,
  222.     JS_PropertyStub, JS_PropertyStub, cookie_getProperty, cookie_setProperty,
  223.     JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, cookie_finalize
  224. };
  225.  
  226. /* cookie.accept() -- mark it okay */
  227. PR_STATIC_CALLBACK(JSBool)
  228. cookie_accept(JSContext *cx, JSObject *obj, uint argc, jsval *argv, jsval * rval)
  229. {
  230.     JSCookieData *data;
  231.  
  232.     if (!(data = (JSCookieData*)JS_GetInstancePrivate(cx, obj, &js_cookie_class, argv)))
  233.         return JS_FALSE;
  234.  
  235.     data->accepted = TRUE;
  236.     data->rejected = FALSE;
  237.     data->ask = FALSE;
  238.     data->decision_made = TRUE;
  239.  
  240.     return JS_TRUE;
  241. }
  242.  
  243. /* cookie.reject() -- reject it out of hand */
  244. PR_STATIC_CALLBACK(JSBool)
  245. cookie_reject(JSContext *cx, JSObject *obj, uint argc, jsval *argv, jsval * rval)
  246. {
  247.     JSCookieData *data;
  248.  
  249.     if (!(data = (JSCookieData*)JS_GetInstancePrivate(cx, obj, &js_cookie_class, argv)))
  250.         return JS_FALSE;
  251.  
  252.     data->accepted = FALSE;
  253.     data->rejected = TRUE;
  254.     data->ask = FALSE;
  255.     data->decision_made = TRUE;
  256.  
  257.     return JS_TRUE;
  258. }
  259.  
  260. /* cookie.ask() -- ask the luser, even if that pref is off */
  261. PR_STATIC_CALLBACK(JSBool)
  262. cookie_ask(JSContext *cx, JSObject *obj, uint argc, jsval *argv, jsval * rval)
  263. {
  264.     JSCookieData *data;
  265.  
  266.     if (!(data = (JSCookieData*)JS_GetInstancePrivate(cx, obj, &js_cookie_class, argv)))
  267.         return JS_FALSE;
  268.  
  269.     data->accepted = FALSE;
  270.     data->rejected = FALSE;
  271.     data->ask = TRUE;
  272.     data->decision_made = TRUE;
  273.  
  274.     return JS_TRUE;
  275. }
  276.  
  277. /* cookie.confirm() -- pop up a confirmation box */
  278. PR_STATIC_CALLBACK(JSBool)
  279. cookie_confirm(JSContext *cx, JSObject *obj, uint argc, jsval *argv, jsval * rval)
  280. {
  281.     JSCookieData *data;
  282.     JSString *str;
  283.     char *msg = (char *)0;
  284.     Bool result;
  285.     MWContext * context = XP_FindSomeContext();
  286.  
  287.     if (argc < 1 || !context)
  288.         return JS_FALSE;
  289.  
  290.     if (!(data = (JSCookieData*)JS_GetInstancePrivate(cx, obj, &js_cookie_class, argv)))
  291.         return JS_FALSE;
  292.  
  293.     str = JS_ValueToString(cx, argv[0]);
  294.     if (!str)
  295.         return JS_FALSE;
  296.  
  297.     StrAllocCopy(msg, XP_GetString(MK_ACCESS_JAVASCRIPT_COOKIE_FILTER));
  298.     StrAllocCat(msg, JS_GetStringBytes(str));
  299.     if (!msg)
  300.         return JS_FALSE;
  301.  
  302.     result = FE_Confirm(context, msg);
  303.     FREEIF(msg);
  304.  
  305.     *rval = BOOLEAN_TO_JSVAL(result);
  306.  
  307.     return JS_TRUE;
  308. }
  309.  
  310. #if DEBUG
  311. /* trace() -- outputs spew to stderr.  Actually, this (or something like it
  312.    that perhaps outputs to the same file that the rest of the filter logging code
  313.    writes to) would probably be very useful in the normal course of writing filters. */
  314. PR_STATIC_CALLBACK(JSBool)
  315. cookie_filter_trace(JSContext *cx, JSObject * obj, uint argc, jsval *argv, jsval * rval)
  316. {
  317.  
  318.         if (argc > 0)
  319.                 {
  320.                         JSString *str;
  321.                         const char *trace_str;
  322.                         if (!(str = JS_ValueToString(cx, argv[0])))
  323.                                 return JS_FALSE;
  324.  
  325.                         trace_str = JS_GetStringBytes(str);
  326.                         if (*trace_str != '\0')
  327.                                 {
  328.                                         fprintf (stderr, "cookie filter trace: %s\n", trace_str);
  329.                                 }
  330.                         return JS_TRUE;
  331.                 }
  332.  
  333.         return JS_FALSE;
  334. }
  335. #endif
  336.  
  337. static JSFunctionSpec cookie_methods[] = {
  338.     { "accept", cookie_accept, 0 },
  339.     { "reject", cookie_reject, 0 },
  340.     { "ask",    cookie_ask, 0 },
  341.     { "confirm", cookie_confirm, 1 },
  342.     { 0 }
  343. };
  344.  
  345. static JSFunctionSpec filter_methods[] = {
  346. #ifdef DEBUG
  347.     { "trace", cookie_filter_trace, 1 },
  348. #endif
  349.     { 0 }
  350. };
  351.  
  352. PRIVATE void
  353. destroyJSCookieFilterStuff(void)
  354. {
  355.         filter_obj = NULL;
  356. }
  357.  
  358. /*
  359.  * This function used to take an MWContext and store it as the private data
  360.  *   of the filter object.  That is a no-no since the filter_obj is going to
  361.  *   be around until the end of time but there is no guarentee that the
  362.  *   context won't get free'd out from under us.  The solution is to not
  363.  *   hold onto any particular context but just call XP_FindSomeContext() or
  364.  *   some derivative of it when we need to.
  365.  */
  366. PRIVATE JSContext *
  367. initializeJSCookieFilterStuff()
  368. {
  369.  
  370.     /* Only bother initializing once */
  371.     if (filter_obj)
  372.         return filter_context;
  373.  
  374.     /* If we can't get the mozilla-thread global context just bail */
  375.     PREF_GetConfigContext(&filter_context);
  376.     if (!filter_context)
  377.         return NULL;
  378.  
  379.     /* create our "global" object.  We make the message object a child of this */
  380.     filter_obj = JS_NewObject(filter_context, &global_class, NULL, NULL);
  381.     
  382.     if (!filter_obj
  383.             || !JS_InitStandardClasses(filter_context, filter_obj)
  384.             || !JS_DefineFunctions(filter_context, filter_obj, filter_methods))
  385.             {
  386.                 destroyJSCookieFilterStuff();
  387.                 return NULL;
  388.             }
  389.  
  390.     return filter_context;
  391. }
  392.  
  393. PRIVATE JSObject *
  394. newCookieObject(void)
  395. {
  396.     JSObject *rv;
  397.     JSCookieData *cookie_data;
  398.  
  399.     rv = JS_DefineObject(filter_context, filter_obj,
  400.                          "cookie", &js_cookie_class,
  401.                          NULL, JSPROP_ENUMERATE);
  402.  
  403.     if( (JSObject *)0 == rv )
  404.         return (JSObject *)0;
  405.  
  406.     cookie_data = XP_NEW_ZAP(JSCookieData);
  407.  
  408.     if( (JSCookieData *)0 == cookie_data )
  409.         return (JSObject *)0;
  410.  
  411.     if( !JS_SetPrivate(filter_context, rv, cookie_data)
  412.         || !JS_DefineProperties(filter_context, rv, cookie_props)
  413.         || !JS_DefineFunctions(filter_context, rv, cookie_methods)) {
  414.         return (JSObject *)0;
  415.     }
  416.  
  417.     return rv;
  418. }
  419.  
  420. PR_STATIC_CALLBACK(void)
  421. jscookie_ErrorReporter(JSContext *cx, const char *message, JSErrorReport *report)
  422. {
  423.     char *msg = NULL;
  424.     MWContext *context;
  425.     
  426.     context = XP_FindSomeContext();
  427.     if(!context || !report)
  428.         return;
  429.  
  430.     /*XXX: i18n-ise this */
  431.     msg = PR_sprintf_append(NULL,
  432.                             "JavaScript Cookie Filter Error:\n"
  433.                             "You will be prompted manually to accept or reject this cookie.\n"
  434.                             "Filename: %s\n"
  435.                             "Line #: %u\n"
  436.                             "%s\n"
  437.                             "%.*s\n",
  438.                             report->filename, 
  439.                             report->lineno, 
  440.                             report->linebuf,
  441.                             (int)(report->tokenptr - report->linebuf) + 1,
  442.                             "^"
  443.                             );
  444.  
  445.     if (!msg)
  446.         return;
  447.  
  448.     FE_Alert(context, msg);
  449.     XP_FREE(msg);
  450.  
  451.     return;
  452. }
  453.  
  454. PRIVATE JSBool
  455. compileJSCookieFilters(void)
  456. {
  457.     static time_t m_time = 0; /* the last modification time of filters.js */
  458.     static JSBool ret_val = JS_FALSE;
  459.     char *filename;
  460.     XP_File fp;
  461.     XP_StatStruct stats;
  462.  
  463.     if (!need_compile)
  464.         return ret_val;
  465.  
  466.     filename = WH_FileName("", xpJSCookieFilters);
  467.  
  468.     XP_Trace("+Filename for script filter is %s\n", filename);
  469.  
  470.     /* If we can't get to the file, get the hell outa dodge. */
  471.     if(XP_Stat(filename, &stats, xpJSCookieFilters))
  472.         return ret_val;
  473.  
  474.     if (stats.st_mtime > m_time || need_compile)
  475.         {
  476.             long fileLength;
  477.             char *buffer;
  478.             jsval rval;
  479.             
  480.             m_time = stats.st_mtime;
  481.             
  482.             fileLength = stats.st_size;
  483.             if (fileLength <= 1)
  484.                     {
  485.                             ret_val = JS_FALSE;
  486.                             return ret_val;
  487.                     }
  488.             
  489.             if( !(fp = XP_FileOpen(filename, xpJSCookieFilters, "r")) ) {
  490.                         ret_val = JS_FALSE;
  491.                         return ret_val;
  492.                     }
  493.             
  494.             buffer = (char*)malloc(fileLength);
  495.             if (!buffer) {
  496.                 XP_FileClose(fp);
  497.                 ret_val = JS_FALSE;
  498.                 return ret_val;
  499.             }
  500.             
  501.             fileLength = XP_FileRead(buffer, fileLength, fp);
  502.  
  503.             XP_FileClose(fp);
  504.  
  505.             XP_Trace("+Compiling filters.js...\n");
  506.  
  507.             ret_val = JS_EvaluateScript(filter_context, filter_obj, buffer, fileLength,
  508.                                                                     filename, 1, &rval);
  509.  
  510.             XP_Trace("+Done.\n");
  511.             
  512.             XP_FREE(buffer);
  513.  
  514.             need_compile = JS_FALSE;
  515.         }
  516.  
  517.     return ret_val;
  518. }
  519.  
  520. PUBLIC JSCFResult 
  521. JSCF_Execute(
  522.                                MWContext *mwcontext,
  523.                                const char *script_name,
  524.                                JSCFCookieData *data,
  525.                                Bool *data_changed
  526.                                )
  527. {
  528.     jsval result;
  529.     jsval filter_arg; /* we will this in with the message object we create. */
  530.     JSObject *cookie_obj;
  531.     JSCookieData *cookie_data;
  532.  
  533.     if (!script_name)
  534.         return JSCF_error;
  535.  
  536.     /* initialize the filter stuff, and bomb out early if it fails */
  537.     if (!initializeJSCookieFilterStuff())
  538.         return JSCF_error;
  539.  
  540.     /* 
  541.      * try loading (reloading if necessary) the filter file before bothering 
  542.      *   to create any JS-objects
  543.      */
  544.     if (!compileJSCookieFilters())
  545.         return JSCF_error;
  546.  
  547.     if (!error_reporter_installed)
  548.         {
  549.             error_reporter_installed = JS_TRUE;
  550.             previous_error_reporter = JS_SetErrorReporter(filter_context,
  551.                                                           jscookie_ErrorReporter);
  552.         }
  553.  
  554.  
  555.     cookie_obj = newCookieObject();
  556.     if( (JSObject *)0 == cookie_obj )
  557.         return JSCF_error;
  558.  
  559.     cookie_data = (JSCookieData *)JS_GetPrivate(filter_context, cookie_obj);
  560.     cookie_data->js_context = filter_context;
  561.     cookie_data->js_object = cookie_obj;
  562.     cookie_data->data = data;
  563.     cookie_data->property_changed = FALSE;
  564.     cookie_data->rejected = FALSE;
  565.     cookie_data->accepted = FALSE;
  566.     cookie_data->decision_made = FALSE;
  567.  
  568.     filter_arg = OBJECT_TO_JSVAL(cookie_obj);
  569.     JS_CallFunctionName(filter_context, filter_obj, script_name, 1, 
  570.                         &filter_arg, &result);
  571.  
  572.     *data_changed = cookie_data->property_changed;
  573.     if( cookie_data->decision_made ) {
  574.         if( cookie_data->rejected )
  575.             return JSCF_reject;
  576.         else if( cookie_data->accepted )
  577.             return JSCF_accept;
  578.         else if( cookie_data->ask )
  579.             return JSCF_ask;
  580.     }
  581.  
  582.     return JSCF_whatever;
  583. }
  584.  
  585. PUBLIC void
  586. JSCF_Cleanup(void)
  587. {
  588.     TRACEMSG(("+Cleaning up JS Cookie Filters"));
  589.  
  590.     need_compile = JS_TRUE;
  591.  
  592.     if (filter_context)
  593.     {
  594.         if (error_reporter_installed)
  595.             {
  596.                 error_reporter_installed = JS_FALSE;
  597.                 JS_SetErrorReporter(filter_context, previous_error_reporter);
  598.             }
  599.  
  600.         JS_GC(filter_context);
  601.  
  602.         destroyJSCookieFilterStuff();
  603.     }
  604. }
  605.