Index: src/date.c
==================================================================
--- src/date.c
+++ src/date.c
@@ -410,16 +410,58 @@
   p->validHMS = 0;
   p->validTZ = 0;
 }
 
 #ifndef SQLITE_OMIT_LOCALTIME
+
+/*
+** The following three functions - osLocaltime_r(), osLocaltime_s() and
+** osLocaltime() - are wrappers around system functions localtime_r(),
+** localtime_s() and localtime(), respectively.
+**
+** If the sqlite3GlobalConfig.bLocaltimeFault variable is true when one
+** of the following wrappers is called, it returns an error.
+*/
+#ifndef SQLITE_OMIT_BUILTIN_TEST
+
+#ifdef HAVE_LOCALTIME_R
+static struct tm * osLocaltime_r(time_t *t, struct tm *pTm){
+  if( sqlite3GlobalConfig.bLocaltimeFault ) return 0;
+  return localtime_r(t);
+}
+#elif defined(HAVE_LOCALTIME_S) && HAVE_LOCALTIME_S
+static int osLocaltime_s(time_t *t, struct tm *pTm){
+  if( sqlite3GlobalConfig.bLocaltimeFault ) return 1;
+  return (int)localtime_s(t, pTm);
+}
+#else
+static struct tm * osLocaltime(time_t *t){
+  if( sqlite3GlobalConfig.bLocaltimeFault ) return 0;
+  return localtime(t);
+}
+#endif
+
+#else
+# define osLocaltime_r(x,y) localtime_r(x,y)
+# define osLocaltime_s(x,y) localtime_s(x,y)
+# define osLocaltime(x)     localtime(x)
+#endif
+
+
 /*
-** Compute the difference (in milliseconds)
-** between localtime and UTC (a.k.a. GMT)
-** for the time value p where p is in UTC.
+** Compute the difference (in milliseconds) between localtime and UTC
+** (a.k.a. GMT) for the time value p where p is in UTC. If no error occurs,
+** return this value and set *pRc to SQLITE_OK. 
+**
+** Or, if an error does occur, set *pRc to SQLITE_ERROR. The returned value
+** is undefined in this case.
 */
-static sqlite3_int64 localtimeOffset(DateTime *p){
+static sqlite3_int64 localtimeOffset(
+  DateTime *p,                    /* Date at which to calculate offset */
+  sqlite3_context *pCtx,          /* Write error here if one occurs */
+  int *pRc                        /* OUT: Error code. SQLITE_OK or ERROR */
+){
   DateTime x, y;
   time_t t;
   x = *p;
   computeYMD_HMS(&x);
   if( x.Y<1971 || x.Y>=2038 ){
@@ -438,11 +480,15 @@
   computeJD(&x);
   t = (time_t)(x.iJD/1000 - 21086676*(i64)10000);
 #ifdef HAVE_LOCALTIME_R
   {
     struct tm sLocal;
-    localtime_r(&t, &sLocal);
+    if( 0==osLocaltime_r(&t, &sLocal) ){
+      sqlite3_result_error(pCtx, "error in localtime_r()", -1);
+      *pRc = SQLITE_ERROR;
+      return 0;
+    }
     y.Y = sLocal.tm_year + 1900;
     y.M = sLocal.tm_mon + 1;
     y.D = sLocal.tm_mday;
     y.h = sLocal.tm_hour;
     y.m = sLocal.tm_min;
@@ -449,11 +495,15 @@
     y.s = sLocal.tm_sec;
   }
 #elif defined(HAVE_LOCALTIME_S) && HAVE_LOCALTIME_S
   {
     struct tm sLocal;
-    localtime_s(&sLocal, &t);
+    if( 0!=osLocaltime_s(&t, &sLocal) ){
+      sqlite3_result_error(pCtx, "error in localtime_s()", -1);
+      *pRc = SQLITE_ERROR;
+      return 0;
+    }
     y.Y = sLocal.tm_year + 1900;
     y.M = sLocal.tm_mon + 1;
     y.D = sLocal.tm_mday;
     y.h = sLocal.tm_hour;
     y.m = sLocal.tm_min;
@@ -461,25 +511,33 @@
   }
 #else
   {
     struct tm *pTm;
     sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
-    pTm = localtime(&t);
-    y.Y = pTm->tm_year + 1900;
-    y.M = pTm->tm_mon + 1;
-    y.D = pTm->tm_mday;
-    y.h = pTm->tm_hour;
-    y.m = pTm->tm_min;
-    y.s = pTm->tm_sec;
+    pTm = osLocaltime(&t);
+    if( pTm ){
+      y.Y = pTm->tm_year + 1900;
+      y.M = pTm->tm_mon + 1;
+      y.D = pTm->tm_mday;
+      y.h = pTm->tm_hour;
+      y.m = pTm->tm_min;
+      y.s = pTm->tm_sec;
+    }
     sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
+    if( !pTm ){
+      sqlite3_result_error(pCtx, "error in localtime()", -1);
+      *pRc = SQLITE_ERROR;
+      return 0;
+    }
   }
 #endif
   y.validYMD = 1;
   y.validHMS = 1;
   y.validJD = 0;
   y.validTZ = 0;
   computeJD(&y);
+  *pRc = SQLITE_OK;
   return y.iJD - x.iJD;
 }
 #endif /* SQLITE_OMIT_LOCALTIME */
 
 /*
@@ -499,13 +557,16 @@
 **     weekday N
 **     unixepoch
 **     localtime
 **     utc
 **
-** Return 0 on success and 1 if there is any kind of error.
+** Return 0 on success and 1 if there is any kind of error. If the error
+** is in a system call (i.e. localtime()), then an error message is written
+** to context pCtx. If the error is an unrecognized modifier, no error is
+** written to pCtx.
 */
-static int parseModifier(const char *zMod, DateTime *p){
+static int parseModifier(sqlite3_context *pCtx, const char *zMod, DateTime *p){
   int rc = 1;
   int n;
   double r;
   char *z, zBuf[30];
   z = zBuf;
@@ -521,13 +582,12 @@
       ** Assuming the current time value is UTC (a.k.a. GMT), shift it to
       ** show local time.
       */
       if( strcmp(z, "localtime")==0 ){
         computeJD(p);
-        p->iJD += localtimeOffset(p);
+        p->iJD += localtimeOffset(p, pCtx, &rc);
         clearYMD_HMS_TZ(p);
-        rc = 0;
       }
       break;
     }
 #endif
     case 'u': {
@@ -544,15 +604,16 @@
       }
 #ifndef SQLITE_OMIT_LOCALTIME
       else if( strcmp(z, "utc")==0 ){
         sqlite3_int64 c1;
         computeJD(p);
-        c1 = localtimeOffset(p);
-        p->iJD -= c1;
-        clearYMD_HMS_TZ(p);
-        p->iJD += c1 - localtimeOffset(p);
-        rc = 0;
+        c1 = localtimeOffset(p, pCtx, &rc);
+        if( rc==SQLITE_OK ){
+          p->iJD -= c1;
+          clearYMD_HMS_TZ(p);
+          p->iJD += c1 - localtimeOffset(p, pCtx, &rc);
+        }
       }
 #endif
       break;
     }
     case 'w': {
@@ -729,13 +790,12 @@
     if( !z || parseDateOrTime(context, (char*)z, p) ){
       return 1;
     }
   }
   for(i=1; i<argc; i++){
-    if( (z = sqlite3_value_text(argv[i]))==0 || parseModifier((char*)z, p) ){
-      return 1;
-    }
+    z = sqlite3_value_text(argv[i]);
+    if( z==0 || parseModifier(context, (char*)z, p) ) return 1;
   }
   return 0;
 }
 
 

Index: src/main.c
==================================================================
--- src/main.c
+++ src/main.c
@@ -2900,10 +2900,21 @@
       pFree = va_arg(ap, void*);
       if( sz ) *ppNew = sqlite3ScratchMalloc(sz);
       sqlite3ScratchFree(pFree);
       break;
     }
+
+    /*   sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff);
+    **
+    ** If parameter onoff is non-zero, configure the wrappers so that all
+    ** subsequent calls to localtime() and variants fail. If onoff is zero,
+    ** undo this setting.
+    */
+    case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
+      sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int);
+      break;
+    }
 
   }
   va_end(ap);
 #endif /* SQLITE_OMIT_BUILTIN_TEST */
   return rc;

Index: src/sqlite.h.in
==================================================================
--- src/sqlite.h.in
+++ src/sqlite.h.in
@@ -5571,11 +5571,12 @@
 #define SQLITE_TESTCTRL_RESERVE                 14
 #define SQLITE_TESTCTRL_OPTIMIZATIONS           15
 #define SQLITE_TESTCTRL_ISKEYWORD               16
 #define SQLITE_TESTCTRL_PGHDRSZ                 17
 #define SQLITE_TESTCTRL_SCRATCHMALLOC           18
-#define SQLITE_TESTCTRL_LAST                    18
+#define SQLITE_TESTCTRL_LOCALTIME_FAULT         19
+#define SQLITE_TESTCTRL_LAST                    19
 
 /*
 ** CAPI3REF: SQLite Runtime Status
 **
 ** ^This interface is used to retrieve runtime status information

Index: src/sqliteInt.h
==================================================================
--- src/sqliteInt.h
+++ src/sqliteInt.h
@@ -2450,10 +2450,11 @@
   int isPCacheInit;                 /* True after malloc is initialized */
   sqlite3_mutex *pInitMutex;        /* Mutex used by sqlite3_initialize() */
   int nRefInitMutex;                /* Number of users of pInitMutex */
   void (*xLog)(void*,int,const char*); /* Function for logging */
   void *pLogArg;                       /* First argument to xLog() */
+  int bLocaltimeFault;              /* True to fail localtime() calls */
 };
 
 /*
 ** Context pointer passed down through the tree-walk.
 */

Index: src/test1.c
==================================================================
--- src/test1.c
+++ src/test1.c
@@ -5519,10 +5519,58 @@
   rc = printExplainQueryPlan(pStmt);
   Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
   return TCL_OK;
 }
 #endif /* SQLITE_OMIT_EXPLAIN */
+
+/*
+** sqlite3_test_control VERB ARGS...
+*/
+static int test_test_control(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  struct Verb {
+    const char *zName;
+    int i;
+  } aVerb[] = {
+    { "SQLITE_TESTCTRL_LOCALTIME_FAULT", SQLITE_TESTCTRL_LOCALTIME_FAULT }, 
+  };
+  int iVerb;
+  int iFlag;
+  int rc;
+
+  if( objc<2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "VERB ARGS...");
+    return TCL_ERROR;
+  }
+
+  rc = Tcl_GetIndexFromObjStruct(
+      interp, objv[1], aVerb, sizeof(aVerb[0]), "VERB", 0, &iVerb
+  );
+  if( rc!=TCL_OK ) return rc;
+
+  iFlag = aVerb[iVerb].i;
+  switch( iFlag ){
+    case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
+      int val;
+      if( objc!=3 ){
+        Tcl_WrongNumArgs(interp, 2, objv, "ONOFF");
+        return TCL_ERROR;
+      }
+      if( Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR;
+      sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, val);
+      break;
+    }
+  }
+
+  Tcl_ResetResult(interp);
+  return TCL_OK;
+}
+
 
 /*
 **      optimization_control DB OPT BOOLEAN
 **
 ** Enable or disable query optimizations using the sqlite3_test_control()
@@ -5783,10 +5831,11 @@
      { "sqlite3_wal_checkpoint_v2",test_wal_checkpoint_v2, 0  },
      { "test_sqlite3_log",         test_sqlite3_log, 0  },
 #ifndef SQLITE_OMIT_EXPLAIN
      { "print_explain_query_plan", test_print_eqp, 0  },
 #endif
+     { "sqlite3_test_control", test_test_control },
   };
   static int bitmask_size = sizeof(Bitmask)*8;
   int i;
   extern int sqlite3_sync_count, sqlite3_fullsync_count;
   extern int sqlite3_opentemp_count;

ADDED   test/tkt-bd484a090c.test
Index: test/tkt-bd484a090c.test
==================================================================
--- /dev/null
+++ test/tkt-bd484a090c.test
@@ -0,0 +1,42 @@
+# 2011 June 21
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# This file contains tests for SQLite. Specifically, it tests that SQLite
+# does not crash and an error is returned if localhost() fails. This 
+# is the problem reported by ticket bd484a090c.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+set testprefix tkt-bd484a090c
+
+
+do_test 1.1 {
+  lindex [catchsql { SELECT datetime('now', 'localtime') }] 0
+} {0}
+do_test 1.2 {
+  lindex [catchsql { SELECT datetime('now', 'utc') }] 0
+} {0}
+
+sqlite3_test_control SQLITE_TESTCTRL_LOCALTIME_FAULT 1
+
+do_test 2.1 {
+  foreach {rc msg} [catchsql { SELECT datetime('now', 'localtime') }] {}
+  set res [string match {error in localtime*()} $msg]
+  list $rc $res
+} {1 1}
+do_test 2.2 {
+  foreach {rc msg} [catchsql { SELECT datetime('now', 'utc') }] {}
+  set res [string match {error in localtime*()} $msg]
+  list $rc $res
+} {1 1}
+
+sqlite3_test_control SQLITE_TESTCTRL_LOCALTIME_FAULT 0
+
+finish_test