Asp.net mvc与PHP的Session共享的实现

--Mysql 数据表的创建代码
CREATE TABLE `sessions` (
  `SessionId` VARCHAR(80) NOT NULL,
  `ApplicationName` VARCHAR(255) NOT NULL,
  `Created` DATETIME NOT NULL,
  `Expires` DATETIME NOT NULL,
  `LockDate` DATETIME NOT NULL,
  `LockId` INT(10) UNSIGNED NOT NULL,
  `Timeout` INT(10) UNSIGNED NOT NULL,
  `Locked` SMALLINT(1) UNSIGNED NOT NULL,
  `SessionItems` LONGTEXT NOT NULL,
  `Flags` INT(10) UNSIGNED NOT NULL,
  PRIMARY KEY (`SessionId`,`ApplicationName`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

public class SessionProvider : SessionStateStoreProviderBase
    {

        private SessionStateSection pConfig = null;
        private string connectionString;
        private ConnectionStringSettings pConnectionStringSettings;
        private string eventSource = "OdbcSessionStateStore";
        private string eventLog = "Application";
        private string exceptionMessage =
          "An exception occurred. Please contact your administrator.";
        private string pApplicationName;


        //
        // If false, exceptions are thrown to the caller. If true,
        // exceptions are written to the event log.
        //

        private bool pWriteExceptionsToEventLog = false;

        public bool WriteExceptionsToEventLog
        {
            get { return pWriteExceptionsToEventLog; }
            set { pWriteExceptionsToEventLog = value; }
        }


        //
        // The ApplicationName property is used to differentiate sessions
        // in the data source by application.
        //

        public string ApplicationName
        {
            get { return pApplicationName; }
        }


        public override void Initialize(string name, NameValueCollection config)
        {
            //
            // Initialize values from web.config.
            //

            if (config == null)
                throw new ArgumentNullException("config");

            if (name == null || name.Length == 0)
                name = "OdbcSessionStateStore";

            if (String.IsNullOrEmpty(config["description"]))
            {
                config.Remove("description");
                config.Add("description", "Sample ODBC Session State Store provider");
            }

            // Initialize the abstract base class.
            base.Initialize(name, config);


            //
            // Initialize the ApplicationName property.
            //

            pApplicationName =
              System.Web.Hosting.HostingEnvironment.ApplicationVirtualPath;


            //
            // Get <sessionState> configuration element.
            //

            Configuration cfg =
              WebConfigurationManager.OpenWebConfiguration(ApplicationName);
            pConfig =
              (SessionStateSection)cfg.GetSection("system.web/sessionState");


            //
            // Initialize connection string.
            //

            pConnectionStringSettings =
              ConfigurationManager.ConnectionStrings["MySqlSessionServices"];

            //if (pConnectionStringSettings == null ||
            //  pConnectionStringSettings.ConnectionString.Trim() == "")
            //{
            //    throw new ProviderException("Connection string cannot be blank.");
            //}

            connectionString = pConnectionStringSettings.ConnectionString;




            //
            // Initialize WriteExceptionsToEventLog
            //

            pWriteExceptionsToEventLog = false;

            //if (config["writeExceptionsToEventLog"] != null)
            //{
            //    if (config["writeExceptionsToEventLog"].ToUpper() == "TRUE")
            //        pWriteExceptionsToEventLog = true;
            //}
        }


        //
        // SessionStateStoreProviderBase members
        //

        public override void Dispose()
        {
        }


        //
        // SessionStateProviderBase.SetItemExpireCallback
        //

        public override bool SetItemExpireCallback(SessionStateItemExpireCallback expireCallback)
        {
            return false;
        }


        //
        // SessionStateProviderBase.SetAndReleaseItemExclusive
        //

        public override void SetAndReleaseItemExclusive(HttpContext context,
          string id,
          SessionStateStoreData item,
          object lockId,
          bool newItem)
        {
            // Serialize the SessionStateItemCollection as a string.
            string sessItems = Serialize((SessionStateItemCollection)item.Items);


            #region odbc代码
            //MySqlConnection conn = new MySqlConnection(connectionString);
            //MySqlCommand cmd;
            //MySqlCommand deleteCmd = null;
            #endregion

            MySqlConnection conn = new MySqlConnection(connectionString);
            MySqlCommand cmd;
            MySqlCommand deleteCmd = null;

            if (newItem)
            {
                // MySqlCommand to clear an existing expired session if it exists.
                deleteCmd = new MySqlCommand("DELETE FROM Sessions " +
                    "WHERE SessionId = ? AND ApplicationName = ? AND Expires < ?", conn);
                deleteCmd.Parameters.Add("@SessionId",MySqlDbType.VarChar, 80).Value = id;
                deleteCmd.Parameters.Add
                  ("@ApplicationName", MySqlDbType.VarChar, 255).Value = ApplicationName;
                deleteCmd.Parameters.Add
                  ("@Expires", MySqlDbType.DateTime).Value = DateTime.Now;

                // MySqlCommand to insert the new session item.
                cmd = new MySqlCommand("INSERT INTO Sessions " +
                  " (SessionId, ApplicationName, Created, Expires, " +
                  "  LockDate, LockId, Timeout, Locked, SessionItems, Flags) " +
                  " Values(?, ?, ?, ?, ?, ? , ?, ?, ?, ?)", conn);
                cmd.Parameters.Add("@SessionId", MySqlDbType.VarChar, 80).Value = id;
                cmd.Parameters.Add
                  ("@ApplicationName", MySqlDbType.VarChar, 255).Value = ApplicationName;
                cmd.Parameters.Add
                  ("@Created", MySqlDbType.DateTime).Value = DateTime.Now;
                cmd.Parameters.Add
                  ("@Expires", MySqlDbType.DateTime).Value = DateTime.Now.AddMinutes((Double)item.Timeout);
                cmd.Parameters.Add
                  ("@LockDate", MySqlDbType.DateTime).Value = DateTime.Now;
                cmd.Parameters.AddWithValue("@LockId", MySqlDbType.Int32).Value = 0;
                cmd.Parameters.Add
                  ("@Timeout", MySqlDbType.Int32).Value = item.Timeout;
                cmd.Parameters.AddWithValue("@Locked", MySqlDbType.Bit).Value = false;
                cmd.Parameters.Add
                  ("@SessionItems", MySqlDbType.VarChar, sessItems.Length).Value = sessItems;
                cmd.Parameters.Add("@Flags", MySqlDbType.Int32).Value = 0;
            }
            else
            {
                // MySqlCommand to update the existing session item.
                cmd = new MySqlCommand(
                  "UPDATE Sessions SET Expires = ?, SessionItems = ?, Locked = ? " +
                  " WHERE SessionId = ? AND ApplicationName = ? AND LockId = ?", conn);
                cmd.Parameters.Add("@Expires", MySqlDbType.DateTime).Value =DateTime.Now.AddMinutes((Double)item.Timeout);
                cmd.Parameters.Add("@SessionItems", MySqlDbType.VarChar, sessItems.Length).Value = sessItems;
                cmd.Parameters.Add("@Locked", MySqlDbType.Bit).Value = false;
                cmd.Parameters.Add("@SessionId", MySqlDbType.VarChar, 80).Value = id;
                cmd.Parameters.Add("@ApplicationName", MySqlDbType.VarChar, 255).Value = ApplicationName;
                cmd.Parameters.Add("@LockId", MySqlDbType.Int32 ).Value = lockId;
            }

            try
            {
                conn.Open();

                if (deleteCmd != null)
                    deleteCmd.ExecuteNonQuery();

                cmd.ExecuteNonQuery();
            }
            catch (MySqlException e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "SetAndReleaseItemExclusive");
                    throw new ProviderException(exceptionMessage);
                }
                else
                    throw e;
            }
            finally
            {
                conn.Close();
            }
        }


        //
        // SessionStateProviderBase.GetItem
        //

        public override SessionStateStoreData GetItem(HttpContext context,
          string id,
          out bool locked,
          out TimeSpan lockAge,
          out object lockId,
          out SessionStateActions actionFlags)
        {
            return GetSessionStoreItem(false, context, id, out locked,
              out lockAge, out lockId, out actionFlags);
        }


        //
        // SessionStateProviderBase.GetItemExclusive
        //

        public override SessionStateStoreData GetItemExclusive(HttpContext context,
          string id,
          out bool locked,
          out TimeSpan lockAge,
          out object lockId,
          out SessionStateActions actionFlags)
        {
            return GetSessionStoreItem(true, context, id, out locked,
              out lockAge, out lockId, out actionFlags);
        }


        //
        // GetSessionStoreItem is called by both the GetItem and 
        // GetItemExclusive methods. GetSessionStoreItem retrieves the 
        // session data from the data source. If the lockRecord parameter
        // is true (in the case of GetItemExclusive), then GetSessionStoreItem
        // locks the record and sets a new LockId and LockDate.
        //

        private SessionStateStoreData GetSessionStoreItem(bool lockRecord,
          HttpContext context,
          string id,
          out bool locked,
          out TimeSpan lockAge,
          out object lockId,
          out SessionStateActions actionFlags)
        {
            // Initial values for return value and out parameters.
            SessionStateStoreData item = null;
            lockAge = TimeSpan.Zero;
            lockId = null;
            locked = false;
            actionFlags = 0;

            // ODBC database connection.
            MySqlConnection conn = new MySqlConnection(connectionString);
            // MySqlCommand for database commands.
            MySqlCommand cmd = null;
            // DataReader to read database record.
            MySqlDataReader reader = null;

            // DateTime to check if current session item is expired.
            DateTime expires;
            // String to hold serialized SessionStateItemCollection.
            string serializedItems = "";
            // True if a record is found in the database.
            bool foundRecord = false;
            // True if the returned session item is expired and needs to be deleted.
            bool deleteData = false;
            // Timeout value from the data store.
            int timeout = 0;

            try
            {
                conn.Open();

                // lockRecord is true when called from GetItemExclusive and
                // false when called from GetItem.
                // Obtain a lock if possible. Ignore the record if it is expired.
                if (lockRecord)
                {
                    cmd = new MySqlCommand(
                      "UPDATE Sessions SET" +
                      " Locked = ?, LockDate = ? " +
                      " WHERE SessionId = ? AND ApplicationName = ? AND Locked = ? AND Expires > ?", conn);
                    cmd.Parameters.Add("@Locked", MySqlDbType.Bit).Value = true;
                    cmd.Parameters.Add("@LockDate", MySqlDbType.DateTime).Value= DateTime.Now;
                    cmd.Parameters.Add("@SessionId", MySqlDbType.VarChar, 80).Value = id;
                    cmd.Parameters.Add("@ApplicationName", MySqlDbType.VarChar, 255).Value = ApplicationName;
                    cmd.Parameters.Add("@Lockid", MySqlDbType.Int32).Value = 0;
                    cmd.Parameters.Add("@Expires", MySqlDbType.DateTime).Value = DateTime.Now;

                    if (cmd.ExecuteNonQuery() == 0)
                        // No record was updated because the record was locked or not found.
                        locked = true;
                    else
                        // The record was updated.

                        locked = false;
                }

                // Retrieve the current session item information.
                cmd = new MySqlCommand(
                  "SELECT Expires, SessionItems, LockId, LockDate, Flags, Timeout " +
                  "  FROM Sessions " +
                  "  WHERE SessionId = ? AND ApplicationName = ?", conn);
                cmd.Parameters.Add("@SessionId", MySqlDbType.VarChar, 80).Value = id;
                cmd.Parameters.Add("@ApplicationName", MySqlDbType.VarChar,
                  255).Value = ApplicationName;

                // Retrieve session item data from the data source.
                reader = cmd.ExecuteReader(CommandBehavior.SingleRow);
                while (reader.Read())
                {
                    expires = reader.GetDateTime(0);

                    if (expires < DateTime.Now)
                    {
                        // The record was expired. Mark it as not locked.
                        locked = false;
                        // The session was expired. Mark the data for deletion.
                        deleteData = true;
                    }
                    else
                        foundRecord = true;

                    serializedItems = reader.GetString(1);
                    lockId = reader.GetInt32(2);
                    lockAge = DateTime.Now.Subtract(reader.GetDateTime(3));
                    actionFlags = (SessionStateActions)reader.GetInt32(4);
                    timeout = reader.GetInt32(5);
                }
                reader.Close();


                // If the returned session item is expired, 
                // delete the record from the data source.
                if (deleteData)
                {
                    cmd = new MySqlCommand("DELETE FROM Sessions " +
                      "WHERE SessionId = ? AND ApplicationName = ?", conn);
                    cmd.Parameters.Add("@SessionId", MySqlDbType.VarChar, 80).Value = id;
                    cmd.Parameters.Add("@ApplicationName", MySqlDbType.VarChar,
                      255).Value = ApplicationName;

                    cmd.ExecuteNonQuery();
                }

                // The record was not found. Ensure that locked is false.
                if (!foundRecord)
                    locked = false;

                // If the record was found and you obtained a lock, then set 
                // the lockId, clear the actionFlags,
                // and create the SessionStateStoreItem to return.
                if (foundRecord && !locked)
                {
                    lockId = (int)lockId + 1;

                    cmd = new MySqlCommand("UPDATE Sessions SET" +
                      " LockId = ?, Flags = 0 " +
                      " WHERE SessionId = ? AND ApplicationName = ?", conn);
                    cmd.Parameters.Add("@LockId", MySqlDbType.Int32).Value = lockId;
                    cmd.Parameters.Add("@SessionId", MySqlDbType.VarChar, 80).Value = id;
                    cmd.Parameters.Add("@ApplicationName", MySqlDbType.VarChar, 255).Value = ApplicationName;

                    cmd.ExecuteNonQuery();

                    // If the actionFlags parameter is not InitializeItem, 
                    // deserialize the stored SessionStateItemCollection.
                    if (actionFlags == SessionStateActions.InitializeItem)
                        item = CreateNewStoreData(context, pConfig.Timeout.Minutes);
                    else
                        item = Deserialize(context, serializedItems, timeout);
                }
            }
            catch (MySqlException e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "GetSessionStoreItem");
                    throw new ProviderException(exceptionMessage);
                }
                else
                    throw e;
            }
            finally
            {
                if (reader != null) { reader.Close(); }
                conn.Close();
            }

            return item;
        }




        //
        // Serialize is called by the SetAndReleaseItemExclusive method to 
        // convert the SessionStateItemCollection into a Base64 string to    
        // be stored in an Access Memo field.
        //

        private string Serialize(SessionStateItemCollection items)
        {
           
            items["LastName"] = "Wilson";
            items["FirstName"] = "Dan";

            string ret = "";
            for (int i = 0; i < items.Count;i++ )
            {
                string str = "";
                if (items[i] != null)
                {
                    str = items.Keys[i] + "|s:" + items[i].ToString().Length + ":\"" + items[i].ToString() + "\";";
                }
                else
                {
                    str = items.Keys[i] + "|N;";
                }
                ret += str;
            }
            return ret;
        }

        #region base64 序列化session
        //
        // DeSerialize is called by the GetSessionStoreItem method to 
        // convert the Base64 string stored in the Access Memo field to a 
        // SessionStateItemCollection.
        //

        //private SessionStateStoreData Deserialize(HttpContext context,
        //  string serializedItems, int timeout)
        //{
        //    MemoryStream ms =
        //      new MemoryStream(Convert.FromBase64String(serializedItems));

        //    SessionStateItemCollection sessionItems =
        //      new SessionStateItemCollection();

        //    if (ms.Length > 0)
        //    {
        //        BinaryReader reader = new BinaryReader(ms);
        //        sessionItems = SessionStateItemCollection.Deserialize(reader);


        //    }

        //    return new SessionStateStoreData(sessionItems,
        //      SessionStateUtility.GetSessionStaticObjects(context),
        //      timeout);
        //}

        #endregion

       /// <summary>
       /// 自定义获取session项
       /// </summary>
       /// <param name="context"></param>
       /// <param name="serializedItems"></param>
       /// <param name="timeout"></param>
       /// <returns></returns>
        private SessionStateStoreData Deserialize(HttpContext context,
         string serializedItems, int timeout)
        {
           
            SessionStateItemCollection sessionItems = new SessionStateItemCollection();

      

            string[] arry = serializedItems.Split(‘;‘);
            foreach (string item in arry)
            {
                if (!string.IsNullOrEmpty(item))
                {
                    string strKey = item.Split(‘|‘)[0];
                    string other = item.Split(‘|‘)[1];
                    string strValue = "";
                    if (other == "N")
                    {
                        sessionItems[strKey]=null;
                    }
                    else if (other.Split(‘:‘).Count() > 2)
                    {//s:1:"1"
                        strValue = other.Split(‘:‘)[2];
                        sessionItems[strKey] = strValue.Replace("\"", "");
                    }
                    else
                    {
                        sessionItems[strKey] = null;
                    }
                }
            }

            return new SessionStateStoreData(sessionItems,
              SessionStateUtility.GetSessionStaticObjects(context),
              timeout);
        }

        public override void ReleaseItemExclusive(HttpContext context,
          string id,
          object lockId)
        {
            MySqlConnection conn = new MySqlConnection(connectionString);
            MySqlCommand cmd =
              new MySqlCommand("UPDATE Sessions SET Locked = 0, Expires = ? " +
              "WHERE SessionId = ? AND ApplicationName = ? AND LockId = ?", conn);
            cmd.Parameters.Add("@Expires", MySqlDbType.DateTime).Value =
              DateTime.Now.AddMinutes(pConfig.Timeout.Minutes);
            cmd.Parameters.Add("@SessionId", MySqlDbType.VarChar, 80).Value = id;
            cmd.Parameters.Add("@ApplicationName", MySqlDbType.VarChar,
              255).Value = ApplicationName;
            cmd.Parameters.Add("@LockId", MySqlDbType.Int32).Value = lockId;

            try
            {
                conn.Open();

                cmd.ExecuteNonQuery();
            }
            catch (MySqlException e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "ReleaseItemExclusive");
                    throw new ProviderException(exceptionMessage);
                }
                else
                    throw e;
            }
            finally
            {
                conn.Close();
            }
        }

        //
        // SessionStateProviderBase.RemoveItem
        //

        public override void RemoveItem(HttpContext context,
          string id,
          object lockId,
          SessionStateStoreData item)
        {
            MySqlConnection conn = new MySqlConnection(connectionString);
            MySqlCommand cmd = new MySqlCommand("DELETE * FROM Sessions " +
              "WHERE SessionId = ? AND ApplicationName = ? AND LockId = ?", conn);
            cmd.Parameters.Add("@SessionId", MySqlDbType.VarChar, 80).Value = id;
            cmd.Parameters.Add("@ApplicationName", MySqlDbType.VarChar,
              255).Value = ApplicationName;
            cmd.Parameters.Add("@LockId", MySqlDbType.Int32).Value = lockId;

            try
            {
                conn.Open();

                cmd.ExecuteNonQuery();
            }
            catch (MySqlException e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "RemoveItem");
                    throw new ProviderException(exceptionMessage);
                }
                else
                    throw e;
            }
            finally
            {
                conn.Close();
            }
        }

        //
        // SessionStateProviderBase.CreateUninitializedItem
        //

        public override void CreateUninitializedItem(HttpContext context,
          string id,
          int timeout)
        {
            //MySqlConnection conn = new MySqlConnection(connectionString);

            MySqlConnection conn = new MySqlConnection(connectionString);

            MySqlCommand cmd = new MySqlCommand("INSERT INTO Sessions " +
              " (SessionId, ApplicationName, Created, Expires, " +
              "  LockDate, LockId, Timeout, Locked, SessionItems, Flags) " +
              " Values(?, ?, ?, ?, ?, ? , ?, ?, ?, ?)", conn);
            cmd.Parameters.Add("@SessionId", MySqlDbType.VarChar, 80).Value = id;
            cmd.Parameters.Add("@ApplicationName", MySqlDbType.VarChar,
              255).Value = ApplicationName;
            cmd.Parameters.Add("@Created", MySqlDbType.DateTime).Value
              = DateTime.Now;
            cmd.Parameters.Add("@Expires", MySqlDbType.DateTime).Value
              = DateTime.Now.AddMinutes((Double)timeout);
            cmd.Parameters.Add("@LockDate", MySqlDbType.DateTime).Value
              = DateTime.Now;
            cmd.Parameters.Add("@LockId", MySqlDbType.Int32).Value = 0;
            cmd.Parameters.Add("@Timeout", MySqlDbType.Int32).Value = timeout;
            cmd.Parameters.Add("@Locked", MySqlDbType.Bit).Value = false;
            cmd.Parameters.Add("@SessionItems", MySqlDbType.VarChar, 0).Value = "";
            cmd.Parameters.Add("@Flags", MySqlDbType.Int32).Value = 1;

            try
            {
                conn.Open();

                cmd.ExecuteNonQuery();
            }
            catch (MySqlException e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "CreateUninitializedItem");
                    throw new ProviderException(exceptionMessage);
                }
                else
                    throw e;
            }
            finally
            {
                conn.Close();
            }
        }

        //
        // SessionStateProviderBase.CreateNewStoreData
        //

        public override SessionStateStoreData CreateNewStoreData(
          HttpContext context,
          int timeout)
        {
            return new SessionStateStoreData(new SessionStateItemCollection(),
              SessionStateUtility.GetSessionStaticObjects(context),
              timeout);
        }

        //
        // SessionStateProviderBase.ResetItemTimeout
        //

        public override void ResetItemTimeout(HttpContext context,
                                              string id)
        {
            MySqlConnection conn = new MySqlConnection(connectionString);
            MySqlCommand cmd =
              new MySqlCommand("UPDATE Sessions SET Expires = ? " +
              "WHERE SessionId = ? AND ApplicationName = ?", conn);
            cmd.Parameters.Add("@Expires", MySqlDbType.DateTime).Value
              = DateTime.Now.AddMinutes(pConfig.Timeout.Minutes);
            cmd.Parameters.Add("@SessionId", MySqlDbType.VarChar, 80).Value = id;
            cmd.Parameters.Add("@ApplicationName", MySqlDbType.VarChar,
              255).Value = ApplicationName;

            try
            {
                conn.Open();

                cmd.ExecuteNonQuery();
            }
            catch (MySqlException e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "ResetItemTimeout");
                    throw new ProviderException(exceptionMessage);
                }
                else
                    throw e;
            }
            finally
            {
                conn.Close();
            }
        }


     

        public override void InitializeRequest(HttpContext context)
        {
        }
        public override void EndRequest(HttpContext context)
        {
        }

        private void WriteToEventLog(Exception e, string action)
        {
            EventLog log = new EventLog();
            log.Source = eventSource;
            log.Log = eventLog;

            string message =
              "An exception occurred communicating with the data source.\n\n";
            message += "Action: " + action + "\n\n";
            message += "Exception: " + e.ToString();

            log.WriteEntry(message);
        }
}

function sess_open($save_path, $session_name) { 
    global $SESS_DBHOST, $SESS_DBNAME, $SESS_DBUSER, $SESS_DBPASS, $SESS_DBH; 

    if (! $SESS_DBH = mysql_pconnect($SESS_DBHOST, $SESS_DBUSER, $SESS_DBPASS)) { 
        echo "<li>Can‘t connect to $SESS_DBHOST as $SESS_DBUSER"; 
        echo "<li>MySQL Error: " . mysql_error(); 
        die; 
    } 

    if (! mysql_select_db($SESS_DBNAME, $SESS_DBH)) { 
        echo "<li>Unable to select database $SESS_DBNAME"; 
        die; 
    } 

    return true; 
} 

function sess_close() { 
    return true; 
} 

function sess_read($key) { 
    global $SESS_DBH, $SESS_LIFE; 

    $qry = "SELECT SessionItems FROM sessions WHERE SessionId = ‘$key‘ and ApplicationName=‘/‘   AND Expires > ‘" .date("Y-m-d H:i:s")."‘"; 
    $qid = mysql_query($qry, $SESS_DBH); 

    if (list($value) = mysql_fetch_row($qid)) { 
        return $value; 
    } 
    //else
    //{
    //    sess_write($key,‘‘);
    //    return ‘‘;
    //}
    return false; 
} 

function sess_write($key, $val) { 
    global $SESS_DBH, $SESS_LIFE; 

    
    $Tnow=date("Y-m-d H:i:s");//当前时间
    $expiry =date("Y-m-d H:i:s", time() + $SESS_LIFE); //过期时间 
    $value = addslashes($val); 

    
    $qry = "INSERT INTO sessions (SessionId, ApplicationName, Created, Expires, ".
            "  LockDate, LockId, Timeout, Locked, SessionItems, Flags) ".
            "  VALUES (‘$key‘,‘/‘, ‘$Tnow‘ ,‘$expiry‘,‘$Tnow‘, 0, 20,0, ‘$value‘,0 )"; 
    $qid = mysql_query($qry, $SESS_DBH); 

    if (! $qid) { 
        $qry = "UPDATE sessions SET Expires = ‘$expiry‘, SessionItems = ‘$value‘ WHERE SessionId = ‘$key‘ AND Expires > ‘" . date("Y-m-d H:i:s")."‘"; 
        $qid = mysql_query($qry, $SESS_DBH); 
    } 

    return $qid; 
} 

function sess_destroy($key) { 
    global $SESS_DBH; 

    $qry = "DELETE FROM sessions WHERE SessionId = ‘$key‘"; 
    $qid = mysql_query($qry, $SESS_DBH); 

    return $qid; 
} 

function sess_gc($maxlifetime) { 
    global $SESS_DBH; 

    $qry = "DELETE FROM sessions WHERE Expires < ‘" . date("Y-m-d H:i:s")."‘"; 
    $qid = mysql_query($qry, $SESS_DBH); 

    return mysql_affected_rows($SESS_DBH); 
} 

session_set_save_handler( 
"sess_open", 
"sess_close", 
"sess_read", 
"sess_write", 
"sess_destroy", 
"sess_gc"); 

session_start();