rhodes 1.4.2 → 1.5.0

data/platform/shared/curl/lib/rhossl.c

@@ -0,0 +1,168 @@
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id: ssluse.c,v 1.243 2009-10-14 02:32:27 gknauf Exp $
+ ***************************************************************************/
+
+/*
+ * Source file for all Rhodes-specific code for the TLS/SSL layer. No code
+ * but sslgen.c should ever call or use these functions.
+ */
+
+#include "setup.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+
+#include "urldata.h"
+#include "sendf.h"
+#include "formdata.h" /* for the boundary function */
+#include "url.h" /* for the ssl config check function */
+#include "inet_pton.h"
+#include "ssluse.h"
+#include "connect.h"
+#include "strequal.h"
+#include "select.h"
+#include "sslgen.h"
+#include "rawstr.h"
+
+#define _MPRINTF_REPLACE /* use the internal *printf() functions */
+#include <curl/mprintf.h>
+
+#ifdef USE_RHOSSL
+
+#include "rhossl.h"
+
+extern void * rho_ssl_create_storage();
+extern void rho_ssl_free_storage(void *);
+extern CURLcode rho_ssl_connect(int sockfd, int nonblocking, int *done, void *storage);
+extern void rho_ssl_shutdown(void *storage);
+extern ssize_t rho_ssl_send(const void *mem, size_t len, void *storage);
+extern ssize_t rho_ssl_recv(char *buf, size_t size, int *wouldblock, void *storage);
+
+/**
+ * Global SSL init
+ *
+ * @retval 0 error initializing SSL
+ * @retval 1 SSL initialized successfully
+ */
+int Curl_rhossl_init(void)
+{
+    return 1;
+}
+
+void Curl_rhossl_cleanup(void)
+{
+}
+
+static CURLcode rhossl_connect_common(struct connectdata *conn, int sockindex,
+                                      bool nonblocking, bool *done)
+{
+    curl_socket_t sockfd = conn->sock[sockindex];
+    struct ssl_connect_data *connssl = &conn->ssl[sockindex];
+    CURLcode retcode;
+
+    if (connssl->state == ssl_connection_complete)
+        return CURLE_OK;
+    
+    connssl->storage = rho_ssl_create_storage();
+    
+    int idone = *done;
+    retcode = rho_ssl_connect(sockfd, nonblocking, &idone, connssl->storage);
+    if (retcode)
+        return retcode;
+    
+    *done = (bool)idone;
+    connssl->state = ssl_connection_complete;
+    
+    return retcode;
+}
+
+CURLcode Curl_rhossl_connect_nonblocking(struct connectdata *conn,
+                                         int sockindex,
+                                         bool *done)
+{
+    return rhossl_connect_common(conn, sockindex, TRUE, done);
+}
+
+CURLcode Curl_rhossl_connect(struct connectdata *conn,
+                             int sockindex)
+{
+    CURLcode retcode;
+    bool done = FALSE;
+    retcode = rhossl_connect_common(conn, sockindex, FALSE, &done);
+    if (retcode)
+        return retcode;
+    
+    DEBUGASSERT(done);
+    return CURLE_OK;
+}
+
+void Curl_rhossl_session_free(void *ptr)
+{
+    free(ptr);
+}
+
+int Curl_rhossl_close_all(struct SessionHandle *data)
+{
+    (void)data;
+    return 0;
+}
+
+void Curl_rhossl_close(struct connectdata *conn, int sockindex)
+{
+    Curl_rhossl_shutdown(conn, sockindex);
+}
+
+int Curl_rhossl_shutdown(struct connectdata *conn, int sockindex)
+{
+    struct ssl_connect_data *connssl = &conn->ssl[sockindex];
+    rho_ssl_shutdown(connssl->storage);
+    return 0;
+}
+
+ssize_t Curl_rhossl_send(struct connectdata *conn, int sockindex, const void *mem, size_t len)
+{
+    struct ssl_connect_data *connssl = &conn->ssl[sockindex];
+    return rho_ssl_send(mem, len, connssl->storage);
+}
+
+ssize_t Curl_rhossl_recv(struct connectdata *conn, int sockindex, char *buf, size_t size, bool *wouldblock)
+{
+    struct ssl_connect_data *connssl = &conn->ssl[sockindex];
+    int iw = *wouldblock;
+    ssize_t ret = rho_ssl_recv(buf, size, &iw, connssl->storage);
+    *wouldblock = (bool)iw;
+    return ret;
+}
+
+size_t Curl_rhossl_version(char *buffer, size_t size)
+{
+    return snprintf(buffer, size, "RhoSSL/1.0");
+}
+
+#endif /* USE_RHOSSL */

data/platform/shared/curl/lib/rhossl.h

@@ -0,0 +1,83 @@
+#ifndef __RHO_SSL_H
+#define __RHO_SSL_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+#ifdef USE_RHOSSL
+/*
+ * This header should only be needed to get included by sslgen.c and rhossl.c
+ */
+
+#include "urldata.h"
+CURLcode Curl_rhossl_connect(struct connectdata *conn, int sockindex);
+CURLcode Curl_rhossl_connect_nonblocking(struct connectdata *conn,
+                                         int sockindex,
+                                         bool *done);
+
+/* close a SSL connection */
+void Curl_rhossl_close(struct connectdata *conn, int sockindex);
+
+/* tell SSL engine to close down all open information regarding connections (and
+   thus session ID caching etc) */
+int Curl_rhossl_close_all(struct SessionHandle *data);
+
+/* function provided for the generic SSL-layer, called when a session id
+   should be freed */
+void Curl_rhossl_session_free(void *ptr);
+
+int Curl_rhossl_init(void);
+void Curl_rhossl_cleanup(void);
+
+ssize_t Curl_rhossl_send(struct connectdata *conn,
+                         int sockindex,
+                         const void *mem,
+                         size_t len);
+ssize_t Curl_rhossl_recv(struct connectdata *conn,
+                         int sockindex,
+                         char *buf,
+                         size_t size,
+                         bool *wouldblock);
+
+size_t Curl_rhossl_version(char *buffer, size_t size);
+
+int Curl_rhossl_shutdown(struct connectdata *conn, int sockindex);
+
+/* API setup for OpenSSL */
+#define curlssl_init Curl_rhossl_init
+#define curlssl_cleanup Curl_rhossl_cleanup
+#define curlssl_connect Curl_rhossl_connect
+#define curlssl_connect_nonblocking Curl_rhossl_connect_nonblocking
+#define curlssl_session_free(x) Curl_rhossl_session_free(x)
+#define curlssl_close_all Curl_rhossl_close_all
+#define curlssl_close Curl_rhossl_close
+#define curlssl_shutdown(x,y) Curl_rhossl_shutdown(x,y)
+#define curlssl_set_engine(x,y) (x=x, y=y, CURLE_FAILED_INIT)
+#define curlssl_set_engine_default(x) (x=x, CURLE_FAILED_INIT)
+#define curlssl_engines_list(x) (x=x, (struct curl_slist *)NULL)
+#define curlssl_send Curl_rhossl_send
+#define curlssl_recv Curl_rhossl_recv
+#define curlssl_version Curl_rhossl_version
+#define curlssl_check_cxn(x) (x=x, -1)
+#define curlssl_data_pending(x,y) (x=x, y=y, 0)
+
+#endif /* USE_RHOSSL */
+#endif /* __RHO_SSL_H */

data/platform/shared/curl/lib/setup.h

@@ -477,7 +477,7 @@ int netware_init(void);
 
 #define LIBIDN_REQUIRED_VERSION "0.4.1"
 
-#if defined(USE_GNUTLS) || defined(USE_SSLEAY) || defined(USE_NSS) || defined(USE_QSOSSL)
+#if defined(USE_GNUTLS) || defined(USE_SSLEAY) || defined(USE_NSS) || defined(USE_QSOSSL) || defined(USE_RHOSSL)
 #define USE_SSL    /* SSL support has been enabled */
 #endif
 

data/platform/shared/curl/lib/sslgen.c

@@ -56,6 +56,7 @@
 #include "gtls.h"   /* GnuTLS versions */
 #include "nssg.h"   /* NSS versions */
 #include "qssl.h"   /* QSOSSL versions */
+#include "rhossl.h" /* Rhodes versions */
 #include "sendf.h"
 #include "rawstr.h"
 #include "url.h"

data/platform/shared/curl/lib/url.c

@@ -698,7 +698,12 @@ CURLcode Curl_init_userdefined(struct UserDefined *set)
    * libcurl 7.10 introduced SSL verification *by default*! This needs to be
    * switched off unless wanted.
    */
+#ifdef OS_ANDROID
+  /* TODO: implement binding with system CA storage and rollback this setting to default */
+  set->ssl.verifypeer = FALSE;
+#else
   set->ssl.verifypeer = TRUE;
+#endif
   set->ssl.verifyhost = 2;
   set->ssh_auth_types = CURLSSH_AUTH_DEFAULT; /* defaults to any auth
                                                       type */

data/platform/shared/curl/lib/urldata.h

@@ -224,6 +224,9 @@ struct ssl_connect_data {
 #ifdef USE_QSOSSL
   SSLHandle *handle;
 #endif /* USE_QSOSSL */
+#ifdef USE_RHOSSL
+  void *storage;
+#endif
 };
 
 struct ssl_config_data {

data/platform/shared/db/DBAdapter.cpp

@@ -105,28 +105,82 @@ void CDBAdapter::open (String strDbPath, String strVer, boolean bTemp)
     getAttrMgr().load(*this);
 }
 
+boolean CDBAdapter::migrateDB(const CDBVersion& dbVer, const String& strRhoDBVer, const String& strAppDBVer )
+{
+    LOG(INFO) + "Try migrate database from " + dbVer.m_strRhoVer + " to " + strRhoDBVer;
+    if ( (dbVer.m_strRhoVer.find("1.4") == 0)&& (strRhoDBVer.find("1.5")==0||strRhoDBVer.find("1.4")==0) )
+    {
+        LOG(INFO) + "No migration required from " + dbVer.m_strRhoVer + " to " + strRhoDBVer;
+        writeDBVersion( CDBVersion(strRhoDBVer, strAppDBVer) );
+        return true;
+    }
+
+    //1.2.x -> 1.5.x,1.4.x
+    if ( (dbVer.m_strRhoVer.find("1.2") == 0)&& (strRhoDBVer.find("1.5")==0||strRhoDBVer.find("1.4")==0) )
+    {
+    //sources
+    //priority INTEGER, ADD
+    //backend_refresh_time int default 0, ADD
+    //id INTEGER PRIMARY KEY, REMOVE
+
+    //changed_values
+    //id INTEGER PRIMARY KEY, REMOVE
+        LOG(INFO) + "Migrate database from " + dbVer.m_strRhoVer + " to " + strRhoDBVer;
+
+        CDBAdapter db;
+        db.open( m_strDbPath, m_strDbVer, true );
+        DBResult( res, db.executeSQL( "ALTER TABLE sources ADD priority INTEGER" ));
+        DBResult( res1, db.executeSQL( "ALTER TABLE sources ADD backend_refresh_time int default 0" ));
+
+        {
+            Vector<int> vecSrcIds;
+            DBResult( res2, db.executeSQL( "SELECT source_id FROM sources" ));
+            for ( ; !res2.isEnd(); res2.next() )
+                vecSrcIds.addElement(res2.getIntByIdx(0));
+
+            for( size_t i = 0; i < vecSrcIds.size(); i++)
+            {
+                DBResult( res3, db.executeSQL( "UPDATE sources SET priority=? where source_id=?", 
+                    vecSrcIds.elementAt(i), vecSrcIds.elementAt(i) ));
+            }
+        }
+        db.close();
+
+        writeDBVersion( CDBVersion(strRhoDBVer, strAppDBVer) );
+
+        return true;
+    }
+
+
+    return false;
+}
+
 void CDBAdapter::checkDBVersion(String& strRhoDBVer)
 {
 	String strAppDBVer = RHOCONF().getString("app_db_version");
 	
 	CDBVersion dbVer = readDBVersion();
 
-	boolean bReset = false;
-	
+	boolean bRhoReset = false;
+    boolean bAppReset = false;
+
 	if ( strRhoDBVer.length() > 0 )
 	{
 		if ( dbVer.m_strRhoVer.compare(strRhoDBVer) != 0 )
-			bReset = true;
+			bRhoReset = true;
 	}
 	if ( strAppDBVer.length() > 0 )
 	{
 		if ( dbVer.m_strAppVer.compare(strAppDBVer) != 0 )
-			bReset = true;
+			bAppReset = true;
 	}
-	
-	if ( bReset )
+
+    if ( bRhoReset && !bAppReset )
+        bRhoReset = !migrateDB(dbVer, strRhoDBVer, strAppDBVer);
+
+	if ( bRhoReset || bAppReset )
 	{
-        LOG(INFO) + "Reset database bacause version is changed.";
+        LOG(INFO) + "Reset database because version is changed.";
 
         CRhoFile::deleteFile(m_strDbPath.c_str());
         CRhoFile::deleteFile((m_strDbPath+"-journal").c_str());

data/platform/shared/db/DBAdapter.h

@@ -212,6 +212,8 @@ public:
     sqlite3_stmt* createInsertStatement(rho::db::CDBResult& res, const String& tableName, CDBAdapter& db, String& strInsert);
 
     virtual DBResultPtr prepareStatement( const char* szSt );
+
+    boolean migrateDB(const CDBVersion& dbVer, const String& strRhoDBVer, const String& strAppDBVer);
 };
 
 }

data/platform/shared/db/DBResult.h

@@ -25,6 +25,7 @@ public:
     boolean getReportNonUnique(){ return m_bReportNonUnique; }
     void setReportNonUnique(boolean bSet){ m_bReportNonUnique = bSet; }
     boolean isNonUnique(){ return m_nErrorCode==SQLITE_CONSTRAINT; }
+    boolean isError(){ return m_nErrorCode!=SQLITE_OK; }
     int     getErrorCode(){ return m_nErrorCode; }
     void    setErrorCode(int nError){ m_nErrorCode=nError; }
 

data/platform/shared/json/RJSONTokener.c

@@ -0,0 +1,583 @@
+/*
+ * $Id: json_tokener.c,v 1.20 2006/07/25 03:24:50 mclark Exp $
+ *
+ * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd.
+ * Michael Clark <michael@metaparadigm.com>
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See COPYING for details.
+ *
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <ctype.h>
+#include <string.h>
+
+#if defined(_WIN32_WCE) || defined(WIN32)
+//#define strdup _strdup
+//extern int _shttpd_strncasecmp(register const char *,register const char *, size_t);
+//#define strncasecmp _shttpd_strncasecmp
+# define strncasecmp _strnicmp
+#endif
+
+#ifdef _MSC_VER
+// warning C4018: '<' : signed/unsigned mismatch
+#pragma warning ( disable : 4018 )
+#endif
+
+#include "bits.h"
+#include "debug.h"
+#include "printbuf.h"
+#include "arraylist.h"
+#include "json_object.h"
+#include "json_tokener.h"
+
+#include "ruby/ext/rho/rhoruby.h"
+
+#if !HAVE_STRNCASECMP && defined(_MSC_VER)
+  /* MSC has the version as _strnicmp */
+# define strncasecmp _strnicmp
+#elif !HAVE_STRNCASECMP
+# error You do not have strncasecmp on your system.
+#endif /* HAVE_STRNCASECMP */
+
+#include "logging/RhoLog.h"
+#undef DEFAULT_LOGCATEGORY
+#define DEFAULT_LOGCATEGORY "RJSON"
+
+static const char* json_null_str = "null";
+static const char* json_true_str = "true";
+static const char* json_false_str = "false";
+
+extern const char* json_tokener_errors[];
+
+void rjson_tokener_reset(struct json_tokener *tok);
+struct json_object* rjson_tokener_parse_ex(struct json_tokener *tok,
+					  const char *str, int len);
+
+struct json_tokener* rjson_tokener_new()
+{
+  struct json_tokener *tok = calloc(1, sizeof(struct json_tokener));
+  tok->pb = printbuf_new();
+  rjson_tokener_reset(tok);
+  return tok;
+}
+
+void rjson_tokener_free(struct json_tokener *tok)
+{
+  rjson_tokener_reset(tok);
+  if(tok) printbuf_free(tok->pb);
+  free(tok);
+}
+
+static void rjson_tokener_reset_level(struct json_tokener *tok, int depth)
+{
+  tok->stack[depth].state = json_tokener_state_eatws;
+  tok->stack[depth].saved_state = json_tokener_state_start;
+  //json_object_put(tok->stack[depth].current);
+  tok->stack[depth].current = NULL;
+  free(tok->stack[depth].obj_field_name);
+  tok->stack[depth].obj_field_name = NULL;
+}
+
+void rjson_tokener_reset(struct json_tokener *tok)
+{
+  int i;
+  for(i = tok->depth; i >= 0; i--)
+    rjson_tokener_reset_level(tok, i);
+  tok->depth = 0;
+  tok->err = json_tokener_success;
+}
+
+VALUE rjson_tokener_parse(const char *str, char** pszError)
+{
+  struct json_tokener* tok;
+  struct json_object* obj;
+
+  tok = rjson_tokener_new();
+  obj = rjson_tokener_parse_ex(tok, str, -1);
+  if(tok->err != json_tokener_success)
+  {
+     if ( pszError )
+     {
+         *pszError = malloc(100);
+         sprintf(*pszError,"JSON error code: %d; Offset: %d", tok->err, tok->char_offset);
+     }
+     
+     obj = 0;
+     //obj = error_ptr(-tok->err);
+  }
+
+  rjson_tokener_free(tok);
+  return (VALUE)obj;
+}
+
+struct json_object* rjson_object_new_object()
+{
+    return (struct json_object*)createHash();
+}
+
+struct json_object* rjson_object_new_array()
+{
+    return (struct json_object*)rho_ruby_create_array();
+}
+
+struct json_object* rjson_object_get(struct json_object *obj)
+{
+    return obj;
+}
+
+struct json_object* rjson_object_new_string(const char *s)
+{
+    return (struct json_object*)rho_ruby_create_string(s);
+}
+
+struct json_object* rjson_object_new_boolean(boolean b)
+{
+    return (struct json_object*)rho_ruby_create_boolean(b);
+}
+
+struct json_object* rjson_object_new_int(int64 i)
+{
+    return (struct json_object*)rho_ruby_create_integer(i);
+}
+
+struct json_object* rjson_object_new_double(double d)
+{
+    return (struct json_object*)rho_ruby_create_double(d);
+}
+
+int rjson_object_array_add(struct json_object *ar,struct json_object *val)
+{
+    rho_ruby_add_to_array((VALUE)ar,(VALUE)val);
+    return 0;
+}
+
+void rjson_object_object_add(struct json_object* hash, const char *key,
+			    struct json_object *val)
+{
+    addHashToHash((VALUE)hash, key, (VALUE)val);
+}
+
+#if !HAVE_STRNDUP
+/* CAW: compliant version of strndup() */
+extern char* strndup(const char* str, size_t n);
+#endif
+
+
+#define state  tok->stack[tok->depth].state
+#define saved_state  tok->stack[tok->depth].saved_state
+#define current tok->stack[tok->depth].current
+#define obj_field_name tok->stack[tok->depth].obj_field_name
+
+struct json_object* rjson_tokener_parse_ex(struct json_tokener *tok,
+					  const char *str, int len)
+{
+  struct json_object *obj = NULL;
+  char c;
+
+  tok->char_offset = 0;
+  tok->err = json_tokener_success;
+
+  do {
+    if(tok->char_offset == len) {
+      if(tok->depth == 0 && state == json_tokener_state_eatws &&
+	 saved_state == json_tokener_state_finish)
+	tok->err = json_tokener_success;
+      else
+	tok->err = json_tokener_continue;
+      goto out;
+    }
+
+    c = *str;
+  redo_char:
+    switch(state) {
+
+    case json_tokener_state_eatws:
+      if(isspace(c)) {
+	/* okay */
+      } else if(c == '/') {
+	printbuf_reset(tok->pb);
+	printbuf_memappend(tok->pb, &c, 1);
+	state = json_tokener_state_comment_start;
+      } else {
+	state = saved_state;
+	goto redo_char;
+      }
+      break;
+
+    case json_tokener_state_start:
+      switch(c) {
+      case '{':
+	state = json_tokener_state_eatws;
+	saved_state = json_tokener_state_object_field_start;
+	current = rjson_object_new_object();
+	break;
+      case '[':
+	state = json_tokener_state_eatws;
+	saved_state = json_tokener_state_array;
+	current = rjson_object_new_array();
+	break;
+      case 'N':
+      case 'n':
+	state = json_tokener_state_null;
+	printbuf_reset(tok->pb);
+	tok->st_pos = 0;
+	goto redo_char;
+      case '"':
+      case '\'':
+	state = json_tokener_state_string;
+	printbuf_reset(tok->pb);
+	tok->quote_char = c;
+	break;
+      case 'T':
+      case 't':
+      case 'F':
+      case 'f':
+	state = json_tokener_state_boolean;
+	printbuf_reset(tok->pb);
+	tok->st_pos = 0;
+	goto redo_char;
+#if defined(__GNUC__)
+	  case '0' ... '9':
+#else
+	  case '0':
+      case '1':
+      case '2':
+      case '3':
+      case '4':
+      case '5':
+      case '6':
+      case '7':
+      case '8':
+      case '9':
+#endif
+      case '-':
+	state = json_tokener_state_number;
+	printbuf_reset(tok->pb);
+	tok->is_double = 0;
+	goto redo_char;
+      default:
+	tok->err = json_tokener_error_parse_unexpected;
+	goto out;
+      }
+      break;
+
+    case json_tokener_state_finish:
+      if(tok->depth == 0) goto out;
+      obj = rjson_object_get(current);
+      rjson_tokener_reset_level(tok, tok->depth);
+      tok->depth--;
+      goto redo_char;
+
+    case json_tokener_state_null:
+      printbuf_memappend(tok->pb, &c, 1);
+      if(strncasecmp(json_null_str, tok->pb->buf,
+		     min(tok->st_pos+1, strlen(json_null_str))) == 0) {
+	if(tok->st_pos == strlen(json_null_str)) {
+	  current = (struct json_object*)rho_ruby_get_NIL();
+	  saved_state = json_tokener_state_finish;
+	  state = json_tokener_state_eatws;
+	  goto redo_char;
+	}
+      } else {
+	tok->err = json_tokener_error_parse_null;
+	goto out;
+      }
+      tok->st_pos++;
+      break;
+
+    case json_tokener_state_comment_start:
+      if(c == '*') {
+	state = json_tokener_state_comment;
+      } else if(c == '/') {
+	state = json_tokener_state_comment_eol;
+      } else {
+	tok->err = json_tokener_error_parse_comment;
+	goto out;
+      }
+      printbuf_memappend(tok->pb, &c, 1);
+      break;
+
+    case json_tokener_state_comment:
+      if(c == '*') state = json_tokener_state_comment_end;
+      printbuf_memappend(tok->pb, &c, 1);
+      break;
+
+    case json_tokener_state_comment_eol:
+      if(c == '\n') {
+	RAWTRACE1("json_tokener_comment: %s", tok->pb->buf);
+	state = json_tokener_state_eatws;
+      } else {
+	printbuf_memappend(tok->pb, &c, 1);
+      }
+      break;
+
+    case json_tokener_state_comment_end:
+      printbuf_memappend(tok->pb, &c, 1);
+      if(c == '/') {
+	RAWTRACE1("json_tokener_comment: %s", tok->pb->buf);
+	state = json_tokener_state_eatws;
+      } else {
+	state = json_tokener_state_comment;
+      }
+      break;
+
+    case json_tokener_state_string:
+      if(c == tok->quote_char) {
+	current = rjson_object_new_string(tok->pb->buf);
+	saved_state = json_tokener_state_finish;
+	state = json_tokener_state_eatws;
+      } else if(c == '\\') {
+	saved_state = json_tokener_state_string;
+	state = json_tokener_state_string_escape;
+      } else {
+	printbuf_memappend(tok->pb, &c, 1);
+      }
+      break;
+
+    case json_tokener_state_string_escape:
+      switch(c) {
+      case '"':
+      case '\\':
+      case '/':
+	printbuf_memappend(tok->pb, &c, 1);
+	state = saved_state;
+	break;
+      case 'b':
+      case 'n':
+      case 'r':
+      case 't':
+	if(c == 'b') printbuf_memappend(tok->pb, "\b", 1);
+	else if(c == 'n') printbuf_memappend(tok->pb, "\n", 1);
+	else if(c == 'r') printbuf_memappend(tok->pb, "\r", 1);
+	else if(c == 't') printbuf_memappend(tok->pb, "\t", 1);
+	state = saved_state;
+	break;
+      case 'u':
+	tok->ucs_char = 0;
+	tok->st_pos = 0;
+	state = json_tokener_state_escape_unicode;
+	break;
+      default:
+	tok->err = json_tokener_error_parse_string;
+	goto out;
+      }
+      break;
+
+    case json_tokener_state_escape_unicode:
+      if(strchr(json_hex_chars, c)) {
+	tok->ucs_char += ((unsigned int)hexdigit(c) << ((3-tok->st_pos++)*4));
+	if(tok->st_pos == 4) {
+	  unsigned char utf_out[3];
+	  if (tok->ucs_char < 0x80) {
+	    utf_out[0] = tok->ucs_char;
+	    printbuf_memappend(tok->pb, (char*)utf_out, 1);
+	  } else if (tok->ucs_char < 0x800) {
+	    utf_out[0] = 0xc0 | (tok->ucs_char >> 6);
+	    utf_out[1] = 0x80 | (tok->ucs_char & 0x3f);
+	    printbuf_memappend(tok->pb, (char*)utf_out, 2);
+	  } else {
+	    utf_out[0] = 0xe0 | (tok->ucs_char >> 12);
+	    utf_out[1] = 0x80 | ((tok->ucs_char >> 6) & 0x3f);
+	    utf_out[2] = 0x80 | (tok->ucs_char & 0x3f);
+	    printbuf_memappend(tok->pb, (char*)utf_out, 3);
+	  }
+	  state = saved_state;
+	}
+      } else {
+	tok->err = json_tokener_error_parse_string;
+	goto out;
+      }
+      break;
+
+    case json_tokener_state_boolean:
+      printbuf_memappend(tok->pb, &c, 1);
+      if(strncasecmp(json_true_str, tok->pb->buf,
+		     min(tok->st_pos+1, strlen(json_true_str))) == 0) {
+	if(tok->st_pos == strlen(json_true_str)) {
+	  current = rjson_object_new_boolean(1);
+	  saved_state = json_tokener_state_finish;
+	  state = json_tokener_state_eatws;
+	  goto redo_char;
+	}
+      } else if(strncasecmp(json_false_str, tok->pb->buf,
+			    min(tok->st_pos+1, strlen(json_false_str))) == 0) {
+	if(tok->st_pos == strlen(json_false_str)) {
+	  current = rjson_object_new_boolean(0);
+	  saved_state = json_tokener_state_finish;
+	  state = json_tokener_state_eatws;
+	  goto redo_char;
+	}
+      } else {
+	tok->err = json_tokener_error_parse_boolean;
+	goto out;
+      }
+      tok->st_pos++;
+      break;
+
+    case json_tokener_state_number:
+      if(c && strchr(json_number_chars, c)) {
+	printbuf_memappend(tok->pb, &c, 1);	
+	if(c == '.' || c == 'e' || c == 'E') tok->is_double = 1;
+      } else {
+	int64 numi;
+	double numd;
+	if(!tok->is_double && sscanf(tok->pb->buf, "%lli", &numi) == 1) {
+	  current = rjson_object_new_int(numi);
+	} else if(tok->is_double && sscanf(tok->pb->buf, "%lf", &numd) == 1) {
+	  current = rjson_object_new_double(numd);
+	} else {
+	  tok->err = json_tokener_error_parse_number;
+	  goto out;
+	}
+	saved_state = json_tokener_state_finish;
+	state = json_tokener_state_eatws;
+	goto redo_char;
+      }
+      break;
+
+    case json_tokener_state_array:
+      if(c == ']') {
+	saved_state = json_tokener_state_finish;
+	state = json_tokener_state_eatws;
+      } else {
+	if(tok->depth >= JSON_TOKENER_MAX_DEPTH-1) {
+	  tok->err = json_tokener_error_depth;
+	  goto out;
+	}
+	state = json_tokener_state_array_add;
+	tok->depth++;
+	rjson_tokener_reset_level(tok, tok->depth);
+	goto redo_char;
+      }
+      break;
+
+    case json_tokener_state_array_add:
+      rjson_object_array_add(current, obj);
+      saved_state = json_tokener_state_array_sep;
+      state = json_tokener_state_eatws;
+      goto redo_char;
+
+    case json_tokener_state_array_sep:
+      if(c == ']') {
+	saved_state = json_tokener_state_finish;
+	state = json_tokener_state_eatws;
+      } else if(c == ',') {
+	saved_state = json_tokener_state_array;
+	state = json_tokener_state_eatws;
+      } else {
+	tok->err = json_tokener_error_parse_array;
+	goto out;
+      }
+      break;
+
+    case json_tokener_state_object_field_start:
+      if(c == '}') {
+	saved_state = json_tokener_state_finish;
+	state = json_tokener_state_eatws;
+      } else if (c == '"' || c == '\'') {
+	tok->quote_char = c;
+	printbuf_reset(tok->pb);
+	state = json_tokener_state_object_field;
+      } else {
+	//tok->err = json_tokener_error_parse_object_key_name;
+	//goto out;
+    tok->quote_char = ':';
+	printbuf_reset(tok->pb);
+    printbuf_memappend(tok->pb, &c, 1);
+	state = json_tokener_state_object_field;
+      }
+      break;
+
+    case json_tokener_state_object_field:
+      if(c == tok->quote_char) {
+	obj_field_name = strdup(tok->pb->buf);
+    saved_state = c == ':' ? json_tokener_state_object_value : json_tokener_state_object_field_end;
+	state = json_tokener_state_eatws;
+      } else if(c == '\\') {
+	saved_state = json_tokener_state_object_field;
+	state = json_tokener_state_string_escape;
+      } else {
+	printbuf_memappend(tok->pb, &c, 1);
+      }
+      break;
+
+    case json_tokener_state_object_field_end:
+      if(c == ':') {
+	saved_state = json_tokener_state_object_value;
+	state = json_tokener_state_eatws;
+      } else {
+	tok->err = json_tokener_error_parse_object_key_sep;
+	goto out;
+      }
+      break;
+
+    case json_tokener_state_object_value:
+      if(tok->depth >= JSON_TOKENER_MAX_DEPTH-1) {
+	tok->err = json_tokener_error_depth;
+	goto out;
+      }
+      state = json_tokener_state_object_value_add;
+      tok->depth++;
+      rjson_tokener_reset_level(tok, tok->depth);
+      goto redo_char;
+
+    case json_tokener_state_object_value_add:
+      rjson_object_object_add(current, obj_field_name, obj);
+      free(obj_field_name);
+      obj_field_name = NULL;
+      saved_state = json_tokener_state_object_sep;
+      state = json_tokener_state_eatws;
+      goto redo_char;
+
+    case json_tokener_state_object_sep:
+      if(c == '}') {
+	saved_state = json_tokener_state_finish;
+	state = json_tokener_state_eatws;
+      } else if(c == ',') {
+	saved_state = json_tokener_state_object_field_start;
+	state = json_tokener_state_eatws;
+      } else {
+	tok->err = json_tokener_error_parse_object_value_sep;
+	goto out;
+      }
+      break;
+
+    }
+    str++;
+    tok->char_offset++;
+  } while(c);
+
+  if(state != json_tokener_state_finish &&
+     saved_state != json_tokener_state_finish)
+    tok->err = json_tokener_error_parse_eof;
+
+ out:
+  if(tok->err == json_tokener_success) 
+      return rjson_object_get(current);
+
+  RAWLOG_ERROR3("rjson_tokener_parse_ex: error %s at offset %d; String: %s",
+      json_tokener_errors[tok->err], tok->char_offset, (tok->pb && tok->pb->buf&&tok->pb->bpos ? tok->pb->buf : "") );
+
+  return NULL;
+}
+
+VALUE rho_json_parse(VALUE v,VALUE str)
+{
+    char* szError = 0;
+    VALUE res = rjson_tokener_parse(getStringFromValue(str), &szError);
+    if ( res != 0 )
+        return res;
+
+    RAWLOG_ERROR1("Incorrect json body.Error:%s", (szError ? szError:""));
+
+    if ( szError )
+        free(szError);
+
+    return rho_ruby_get_NIL();
+}