void MethodResultJni::callRubyBack(jboolean jReleaseCallback) { RAWTRACE(__FUNCTION__); RAWTRACE(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"); jhstring jhStrCallbackData = getStrCallbackData(m_env); jlong jRubyProc = getRubyProcCallback(m_env); if (jRubyProc != 0) { VALUE oProc = static_cast<VALUE>(jRubyProc); rho::String strResBody = RHODESAPP().addCallbackObject(new CRubyCallbackResult<MethodResultJni>(*this), "body"); RAWTRACE1("Call Ruby proc by address: 0x%.8x", oProc); RHODESAPP().callCallbackProcWithData( oProc, strResBody, rho_cast<rho::String>(m_env, jhStrCallbackData.get()), true); if(static_cast<bool>(jReleaseCallback)) { releaseRubyProcCallback(jRubyProc); } } else { jhstring jhStrCallback = getStrCallback(m_env); String strCallback = rho_cast<String>(m_env, jhStrCallback.get()); if(strCallback.length()) { RAWTRACE1("Call Ruby controller by URL: %s", rho_cast<rho::String>(jhStrCallback.get()).c_str()); rho::String strResBody = RHODESAPP().addCallbackObject(new CRubyCallbackResult<MethodResultJni>(*this), "__rho_inline"); RHODESAPP().callCallbackWithData(rho_cast<rho::String>(m_env, jhStrCallback.get()), strResBody, rho_cast<rho::String>(m_env, jhStrCallbackData.get()), true); } } }
MethodResultJni::MethodResultJni(const MethodResultJni& result) : m_env(0), m_jhResult(0), m_bGlobalRef(false), m_bSlaveRef(false), m_hasCallback(false), m_resType(typeNone) { JNIEnv* env = result.m_env; if(result.m_bGlobalRef) { RAWTRACE1("Copying MethodResult with global JNI reference: 0x%.8x ---------------------------------------", result.m_jhResult.get()); m_jhResult = result.m_jhResult.get(); result.m_bSlaveRef = true; } else { m_jhResult = env->NewGlobalRef(result.m_jhResult.get()); RAWTRACE1("Copying MethodResult creating global JNI reference: 0x%.8x >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>", m_jhResult.get()); } m_bGlobalRef = true; }
const PbPageParam* rho_phonebook_getpageparams(rho_param* param, PbPageParam* page) { bool offset = false; bool per_page = false; if(param == 0 || page == 0) { RAWTRACE2("Param(0x%.8X) or page(0x%.8X) is NULL, skipping", param, page); return 0; } if (param->type == RHO_PARAM_HASH) { for (int i = 0, lim = param->v.hash->size; i < lim; ++i) { const char* key = param->v.hash->name[i]; rho_param* value = param->v.hash->value[i]; if (strcasecmp(key, "offset") == 0) { RAWTRACE("'offset' parameter found"); if (value->type == RHO_PARAM_STRING) { RAWTRACE1("'offset' parameter is string: %s", value->v.string); sscanf(value->v.string, "%d", &page->offset); offset = true; } } else if (strcasecmp(key, "per_page") == 0) { RAWTRACE("'per_page' parameter found"); if (value->type == RHO_PARAM_STRING) { RAWTRACE1("'per_page' parameter is string: %s", value->v.string); sscanf(value->v.string, "%d", &page->per_page); per_page = true; } } if(offset && per_page) break; } } else { RAWTRACE("rho_param is not a hash!"); } if(!offset) page->offset = 0; if(!per_page) page->per_page = -1; return page; }
int MethodResultJni::getResultType(JNIEnv* env) const { RAWTRACE(__FUNCTION__); if(m_resType == typeNone && m_jhResult) { m_javaResultType = env->CallIntMethod(m_jhResult.get(), s_midGetResultType); RAWTRACE1("Java result type: %d", m_javaResultType); return m_javaResultType; } else { RAWTRACE1("Native result type: %d", m_resType); return m_resType; } }
static size_t curlHeaderCallback(void *ptr, size_t size, size_t nmemb, void *opaque) { Hashtable<String,String>* pHeaders = (Hashtable<String,String>*)opaque; size_t nBytes = size*nmemb; String strHeader((const char *)ptr, nBytes); RAWTRACE1("Received header: %s", strHeader.c_str()); int nSep = strHeader.find(':'); if (nSep > 0 ) { String strName = String_trim(strHeader.substr(0, nSep)); String lName; std::transform(strName.begin(), strName.end(), std::back_inserter(lName), &::tolower); String strValue = String_trim(strHeader.substr(nSep+1, strHeader.length() - (nSep+3) )); if ( pHeaders->containsKey(lName) ) { strValue += ";" + pHeaders->get( lName ); pHeaders->put( lName, strValue ); } else pHeaders->put(lName, strValue); } return nBytes; }
int CURLNetRequest::getResponseCode(CURLcode err, char const *body, size_t bodysize, IRhoSession* oSession ) { //if (err != CURLE_OK) // return -1; if (!body) { body = ""; bodysize = 0; } long statusCode = 0; CURL *curl = m_curl.curl(); if (curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &statusCode) != 0) statusCode = 500; if (statusCode == 416) { statusCode = 206; } if (statusCode >= 400) { RAWLOG_ERROR2("Request failed. HTTP Code: %d returned. HTTP Response: %s", (int)statusCode, body); if (statusCode == 401) if (oSession) oSession->logout(); } else { RAWTRACE1("RESPONSE----- (%d bytes)", bodysize); RAWTRACE(body); RAWTRACE("END RESPONSE-----"); } return (int)statusCode; }
VALUE require_compiled(VALUE fname, VALUE* result) { VALUE path; char* szName = 0; // FilePathValue(fname); szName = RSTRING_PTR(fname); RAWTRACE1("require_compiled: %s", szName); rb_funcall(fname, rb_intern("sub!"), 2, rb_str_new2(".rb"), rb_str_new2("") ); if ( strcmp("strscan",szName)==0 || strcmp("enumerator",szName)==0 ) return Qtrue; path = find_file(fname); if ( path != 0 ) { VALUE seq; if ( isAlreadyLoaded(path) == Qtrue ) return Qtrue; rb_ary_push(GET_VM()->loaded_features, path); seq = loadISeqFromFile(path); //*result = rb_funcall(seq, rb_intern("eval"), 0 ); *result = rb_iseq_eval(seq); return Qtrue; } return Qnil; }
void MapProvider::unregisterMapEngine(String const &id) { RAWTRACE1("Unregister map engine: id=%s", id.c_str()); IMapEngine *engine = m_engines.get(id); if (engine) delete engine; m_engines.remove(id); }
static size_t curlBodyStringCallback(void *ptr, size_t size, size_t nmemb, void *opaque) { String *pStr = (String *)opaque; size_t nBytes = size*nmemb; RAWTRACE1("Received %d bytes", nBytes); pStr->append((const char *)ptr, nBytes); return nBytes; }
static size_t curlBodyBinaryCallback(void *ptr, size_t size, size_t nmemb, void *opaque) { Vector<char> *pBody = (Vector<char> *)opaque; size_t nBytes = size*nmemb; RAWTRACE1("Received %d bytes", nBytes); std::copy((char*)ptr, (char*)ptr + nBytes, std::back_inserter(*pBody)); return nBytes; }
MethodResultJni::~MethodResultJni() { if(m_bGlobalRef) { jobject jResult = m_jhResult.release(); if(!m_bSlaveRef) { RAWTRACE1("Deleting MethodResult global JNI reference: 0x%.8x ==========================================", jResult); m_env->DeleteGlobalRef(jResult); } } }
void CBarcode1::setDefaultID(const rho::String& id) { RAWTRACE1("setDefaultID(id = \"%s\")", id.c_str()); JNIEnv *env = jniInit(); if (!env) { RAWLOG_ERROR("JNI initialization failed"); return; } jhobject instance = getSingleton(env); jhstring jhId = rho_cast<jstring>(env, id); env->CallVoidMethod(instance.get(), s_midSetDefaultID, jhId.get()); }
unsigned long CRhoTimer::getNextTimeout() { synchronized(m_mxAccess); if ( (m_arItems.size() == 0) && (m_arNativeItems.size() == 0) ) return 0; CTimeInterval curTime = CTimeInterval::getCurrentTime(); unsigned long nMinInterval = ((unsigned long)-1); for( int i = 0; i < (int)m_arItems.size(); i++ ) { unsigned long nInterval = 0; if ( m_arItems.elementAt(i).m_oFireTime.toULong() > curTime.toULong() ) { nInterval = m_arItems.elementAt(i).m_oFireTime.toULong() - curTime.toULong(); } else { nInterval=nMinInterval+m_arItems.elementAt(i).m_oFireTime.toULong() - curTime.toULong(); } if ( nInterval < nMinInterval ) nMinInterval = nInterval; } for( int i = 0; i < (int)m_arNativeItems.size(); i++ ) { unsigned long nInterval = 0; if ( m_arNativeItems.elementAt(i).m_oFireTime.toULong() > curTime.toULong() ) { nInterval = m_arNativeItems.elementAt(i).m_oFireTime.toULong() - curTime.toULong(); } else { nInterval=nMinInterval+m_arNativeItems.elementAt(i).m_oFireTime.toULong() - curTime.toULong(); } if ( nInterval < nMinInterval ) nMinInterval = nInterval; } if ( nMinInterval < 100 ) nMinInterval = 100; RAWTRACE1("CRhoTimer::getNextTimeout: %d",nMinInterval); return nMinInterval; }
std::string rho_cast_helper<std::string, jstring>::operator()(JNIEnv *env, jstring s) { if(env->IsSameObject(s, NULL) == JNI_TRUE) { //Avoid crash in case of null java reference RAWTRACE("rho_cast<string, jstring>: \"\""); return std::string(); } else { const char *ts = env->GetStringUTFChars(s, JNI_FALSE); std::string ret(ts); env->ReleaseStringUTFChars(s, ts); RAWTRACE1("rho_cast<string, jstring>: %s", ret.c_str()); return ret; } }
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_api_MethodResult_nativeCallBack (JNIEnv * env, jobject jResult, jint jTabId, jboolean jIsRuby, jboolean jReleaseCallback) { RAWTRACE1("nativeCallBack - env: 0x%.8x", env); initjnienv(env); MethodResultJni result(env, jResult); if (static_cast<bool>(jIsRuby)) { result.callRubyBack(jReleaseCallback); } else { result.callJSBack(jTabId); } }
void CBarcode1::setJavaFactory(JNIEnv* env, jobject jFactory) { RAWTRACE("setJavaFactory"); env = jniInit(env); if (!env) { RAWLOG_ERROR("JNI initialization failed"); return; } RAWTRACE1("s_clsFactorySingleton: 0x%.8X ------------------------------------", s_clsFactorySingleton); env->CallStaticVoidMethod(s_clsFactorySingleton, s_midFactorySetInstance, jFactory); RAWTRACE("setJavaFactory succeeded"); }
MethodResultJni::~MethodResultJni() { if(m_bhasLocalFrame && m_env) { m_bhasLocalFrame = false; m_env->PopLocalFrame(NULL); } if(m_bGlobalRef) { jobject jResult = m_jhResult.release(); if(!m_bSlaveRef) { RAWTRACE1("Deleting MethodResult global JNI reference: 0x%.8x ==========================================", jResult); m_env->DeleteGlobalRef(jResult); } } }
extern "C" void Init_Led(void) { RAWTRACE(__FUNCTION__); JNIEnv *env = jnienv(); if(env) { jclass cls = rho_find_class(env, LED_FACTORY_CLASS); if(!cls) { RAWLOG_ERROR1("Failed to find java class: %s", LED_FACTORY_CLASS); return; } jmethodID midFactory = env->GetMethodID(cls, "<init>", "()V"); if(!midFactory) { RAWLOG_ERROR1("Failed to get constructor for java class %s", LED_FACTORY_CLASS); return; } jobject jFactory = env->NewObject(cls, midFactory); if(env->IsSameObject(jFactory, NULL)) { RAWLOG_ERROR1("Failed to create %s instance", LED_FACTORY_CLASS); return; } RAWTRACE("Initializing Java factory"); rho::notification::CLedBase::setJavaFactory(env, jFactory); RAWTRACE("Deleting JNI reference"); env->DeleteLocalRef(jFactory); RAWTRACE("Initializing API"); Init_Led_API(); RAWTRACE1("%s succeeded", __FUNCTION__); } else { RAWLOG_ERROR1("%s failed: jnienv() is failed", __FUNCTION__); } }
void CRhoTimer::stopTimer(const char* szCallback) { RAWTRACE1("CRhoTimer::stopTimer: %s",szCallback); synchronized(m_mxAccess); if ( !szCallback || !*szCallback) m_arItems.removeAllElements(); for( int i = (int)m_arItems.size()-1; i >= 0; i--) { CTimerItem oItem = m_arItems.elementAt(i); if ( oItem.m_strCallback.compare(szCallback) == 0 ) { m_arItems.removeElementAt(i); } } }
static VALUE db_execute(int argc, VALUE *argv, VALUE self) { sqlite3 * db = NULL; void **ppDB = NULL; sqlite3_stmt *statement = NULL; const char* sql = NULL; VALUE arRes = rb_ary_new(); VALUE* colNames = NULL; int nRes = 0; char * szErrMsg = 0; int is_batch = 0; if ((argc < 2) || (argc > 3)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); Data_Get_Struct(self, void *, ppDB); db = (sqlite3 *)rho_db_get_handle(*ppDB); sql = RSTRING_PTR(argv[0]); is_batch = argv[1] == Qtrue ? 1 : 0; RAWTRACE1("db_execute: %s", sql); PROF_START_CREATED("SQLITE"); if ( is_batch ) { PROF_START_CREATED("SQLITE_EXEC"); rho_db_lock(*ppDB); nRes = sqlite3_exec(db, sql, NULL, NULL, &szErrMsg); rho_db_unlock(*ppDB); PROF_STOP("SQLITE_EXEC"); } else { rho_db_lock(*ppDB); PROF_START_CREATED("SQLITE_PREPARE"); nRes = rho_db_prepare_statement(*ppDB, sql, -1, &statement); PROF_STOP("SQLITE_PREPARE"); //nRes = sqlite3_prepare_v2(db, sql, -1, &statement, NULL); if ( nRes != SQLITE_OK) { szErrMsg = (char *)sqlite3_errmsg(db); rho_db_unlock(*ppDB); rb_raise(rb_eArgError, "could not prepare statement: %d; Message: %s",nRes, (szErrMsg?szErrMsg:"")); } if ( argc > 2 ) { int i = 0; VALUE args = argv[2]; if ( RARRAY_LEN(args) > 0 && TYPE(RARRAY_PTR(args)[0]) == T_ARRAY ) args = RARRAY_PTR(args)[0]; for( ; i < RARRAY_LEN(args); i++ ) { VALUE arg = RARRAY_PTR(args)[i]; if (NIL_P(arg)) { sqlite3_bind_null(statement, i+1); continue; } switch( TYPE(arg) ) { case T_STRING: sqlite3_bind_text(statement, i+1, RSTRING_PTR(arg), RSTRING_LEN(arg), SQLITE_TRANSIENT); break; case T_FLOAT: sqlite3_bind_double(statement, i+1, NUM2DBL(arg)); break; case T_FIXNUM: case T_BIGNUM: sqlite3_bind_int64(statement, i+1, NUM2LL(arg)); break; default: { VALUE strVal = rb_funcall(arg, rb_intern("to_s"), 0); sqlite3_bind_text(statement, i+1, RSTRING_PTR(strVal), -1, SQLITE_TRANSIENT); } break; } } } PROF_START_CREATED("SQLITE_EXEC"); nRes = sqlite3_step(statement); PROF_STOP("SQLITE_EXEC"); while( nRes== SQLITE_ROW ) { int nCount = sqlite3_data_count(statement); int nCol = 0; VALUE hashRec = rb_hash_new(); //if ( !colNames ) // colNames = getColNames(statement, nCount); for(;nCol<nCount;nCol++){ int nColType = sqlite3_column_type(statement,nCol); const char* szColName = sqlite3_column_name(statement,nCol); VALUE colName = rb_str_new2(szColName); VALUE colValue = Qnil; switch(nColType){ case SQLITE_NULL: break; case SQLITE_FLOAT: { double dVal = sqlite3_column_double(statement, nCol); colValue = DBL2NUM(dVal); break; } case SQLITE_INTEGER: { sqlite_int64 nVal = sqlite3_column_int64(statement, nCol); colValue = LL2NUM(nVal); break; } default:{ sqlite3_value * sqlValue = sqlite3_column_value(statement, nCol); int nLen = sqlite3_value_bytes(sqlValue); const char* szValue = (const char *)sqlite3_value_text(sqlValue); //char *text = (char *)sqlite3_column_text(statement, nCol); colValue = rb_str_new(szValue, nLen); break; } } rb_hash_aset(hashRec, colName/*colNames[nCol]*/, colValue); } rb_ary_push(arRes, hashRec); PROF_START_CREATED("SQLITE_EXEC"); nRes = sqlite3_step(statement); PROF_STOP("SQLITE_EXEC"); } rho_db_unlock(*ppDB); } if ( statement ) //sqlite3_finalize(statement); sqlite3_reset(statement); if ( colNames ) free(colNames); if ( nRes != SQLITE_OK && nRes != SQLITE_ROW && nRes != SQLITE_DONE ) { if ( !szErrMsg ) szErrMsg = (char*)sqlite3_errmsg(db); rb_raise(rb_eArgError, "could not execute statement: %d; Message: %s",nRes, (szErrMsg?szErrMsg:"")); } PROF_STOP("SQLITE"); return arRes; }
jstring rho_cast_helper<jstring, char const *>::operator()(JNIEnv *env, char const *s) { RAWTRACE1("rho_cast<jstring, string>: %s", s); return s ? env->NewStringUTF(s) : (jstring)0; }
jobject event_cast<jobject, VALUE>(VALUE rEvent) { if (NIL_P(rEvent)) return NULL; RHO_TRACE("eventFromRuby (1)"); JNIEnv *env = jnienv(); if (!init_event_stuff(env)) return NULL; RHO_TRACE("eventFromRuby (2)"); VALUE rId = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_ID)); if (NIL_P(rId)) rId = rb_str_new2(""); Check_Type(rId, T_STRING); RHO_TRACE("eventFromRuby (3)"); jmethodID mid = getJNIClassMethod(env, clsEvent, "<init>", "(Ljava/lang/String;)V"); if (!mid) return NULL; jobject jEvent = env->NewObject(clsEvent, mid, rho_cast<jhstring>(RSTRING_PTR(rId)).get()); if (!jEvent) return NULL; RHO_TRACE("eventFromRuby (4)"); VALUE rTitle = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_TITLE)); if (!NIL_P(rTitle)) { Check_Type(rTitle, T_STRING); env->SetObjectField(jEvent, fidTitle, rho_cast<jhstring>(RSTRING_PTR(rTitle)).get()); } RHO_TRACE("eventFromRuby (5)"); VALUE rStartDate = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_START_DATE)); if (!NIL_P(rStartDate)) env->SetObjectField(jEvent, fidStartDate, date_cast<jobject>(rStartDate)); RHO_TRACE("eventFromRuby (6)"); VALUE rEndDate = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_END_DATE)); if (!NIL_P(rEndDate)) env->SetObjectField(jEvent, fidEndDate, date_cast<jobject>(rEndDate)); RHO_TRACE("eventFromRuby (7)"); VALUE rLastModified = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_LAST_MODIFIED)); if (!NIL_P(rLastModified)) env->SetObjectField(jEvent, fidLastModified, date_cast<jobject>(rLastModified)); RHO_TRACE("eventFromRuby (8)"); VALUE rLocation = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_LOCATION)); if (!NIL_P(rLocation)) { Check_Type(rLocation, T_STRING); env->SetObjectField(jEvent, fidLocation, rho_cast<jhstring>(RSTRING_PTR(rLocation)).get()); } RHO_TRACE("eventFromRuby (9)"); VALUE rNotes = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_NOTES)); if (!NIL_P(rNotes)) { Check_Type(rNotes, T_STRING); env->SetObjectField(jEvent, fidNotes, rho_cast<jhstring>(RSTRING_PTR(rNotes)).get()); } RHO_TRACE("eventFromRuby privacy"); VALUE rPrivacy = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_PRIVACY)); if (!NIL_P(rPrivacy)) { Check_Type(rPrivacy, T_STRING); env->SetObjectField(jEvent, fidPrivacy, rho_cast<jhstring>(RSTRING_PTR(rPrivacy)).get()); } RHO_TRACE("eventFromRuby recurrence"); VALUE rRecurrence = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_RECURRENCE)); if (!NIL_P(rRecurrence)) { Check_Type(rRecurrence, T_HASH); VALUE rFrequency = rb_hash_aref(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_FREQUENCY)); Check_Type(rFrequency, T_STRING); const char *frequency = RSTRING_PTR(rFrequency); if ( strcasecmp(frequency, RUBY_EV_RECURRENCE_FREQUENCY_DAILY) != 0 && strcasecmp(frequency, RUBY_EV_RECURRENCE_FREQUENCY_WEEKLY) != 0 && strcasecmp(frequency, RUBY_EV_RECURRENCE_FREQUENCY_MONTHLY) != 0 && strcasecmp(frequency, RUBY_EV_RECURRENCE_FREQUENCY_YEARLY) != 0) { rb_raise(rb_eArgError, "Wrong recurrence frequency: %s", frequency); } env->SetObjectField(jEvent, fidFrequency, rho_cast<jhstring>(RSTRING_PTR(rFrequency)).get()); VALUE rInterval = rb_hash_aref(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_INTERVAL)); rInterval = rb_funcall(rInterval, rb_intern("to_i"), 0); int interval = NUM2INT(rInterval); env->SetIntField(jEvent, fidInterval, interval); RAWTRACE1("eventFromRuby recurrence interval: %d", interval); VALUE rUntilDate = rb_hash_aref(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_END)); if (!NIL_P(rUntilDate)) { env->SetObjectField(jEvent, fidRecurrenceEnd, date_cast<jobject>(rUntilDate)); RAWTRACE("eventFromRuby recurrence until date"); } VALUE rTimes = rb_funcall(rb_hash_aref(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_COUNT)), rb_intern("to_i"), 0);; int times = NUM2INT(rTimes); env->SetIntField(jEvent, fidRecurrenceTimes, times); RAWTRACE1("eventFromRuby recurrence count: %d", times); } RHO_TRACE("eventFromRuby: return"); return jEvent; }
RHO_GLOBAL int rho_net_ping_network(const char* szHost) { RAWTRACE1("Ping host: %s", szHost); return 1; }
bool CHttpServer::receive_request(ByteVector &request) { if (verbose) RAWTRACE("Receiving request..."); ByteVector r; char buf[BUF_SIZE]; int attempts = 0; for(;;) { if (verbose) RAWTRACE("Read portion of data from socket..."); int n = recv(m_sock, &buf[0], sizeof(buf), 0); //RAWTRACE1("RECV: %d", n); if (n == -1) { int e = RHO_NET_ERROR_CODE; if (verbose) RAWTRACE1("RECV ERROR: %d", e); #if !defined(WINDOWS_PLATFORM) if (e == EINTR) continue; #else if (e == WSAEINTR) continue; #endif #if defined(OS_WP8) || (defined(RHODES_QT_PLATFORM) && defined(OS_WINDOWS_DESKTOP)) || defined(OS_WINCE) if (e == EAGAIN || e == WSAEWOULDBLOCK) { #else if (e == EAGAIN) { #endif if (!r.empty()) break; if(++attempts > (HTTP_EAGAIN_TIMEOUT*10)) { if (verbose) RAWLOG_ERROR("Error when receiving data from socket. Client does not send data for " HTTP_EAGAIN_TIMEOUT_STR " sec. Cancel recieve."); return false; } fd_set fds; FD_ZERO(&fds); FD_SET(m_sock, &fds); timeval tv = {0}; tv.tv_usec = 100000;//100 MS select(m_sock + 1, &fds, 0, 0, &tv); continue; } if (verbose) RAWLOG_ERROR1("Error when receiving data from socket: %d", e); return false; } if (n == 0) { if(!r.empty()) { if (verbose) RAWTRACE("Client closed connection gracefully"); break; } else { if (verbose) RAWLOG_ERROR("Connection gracefully closed before we receive any data"); return false; } } else { if (verbose) RAWTRACE1("Actually read %d bytes", n); r.insert(r.end(), &buf[0], &buf[0] + n); } } if (!r.empty()) { request.insert(request.end(), r.begin(), r.end()); if ( !rho_conf_getBool("log_skip_post") ) { String strRequest(request.begin(),request.end()); if (verbose) RAWTRACE1("Received request:\n%s", strRequest.c_str()); } } return true; } bool CHttpServer::send_response_impl(String const &data, bool continuation) { #ifdef OS_MACOSX if ( m_localResponseWriter != 0 ) { m_localResponseWriter->writeResponse( data ); return true; } #endif if (verbose) { if (continuation) if (verbose) RAWTRACE("Send continuation data..."); else if (verbose) RAWTRACE("Sending response..."); } // First of all, make socket blocking #if defined(WINDOWS_PLATFORM) unsigned long optval = 0; if(::ioctlsocket(m_sock, FIONBIO, &optval) == SOCKET_ERROR) { RAWLOG_ERROR1("Can not set blocking socket mode: %d", RHO_NET_ERROR_CODE); return false; } #else int flags = fcntl(m_sock, F_GETFL); if (flags == -1) { if (verbose) RAWLOG_ERROR1("Can not get current socket mode: %d", errno); return false; } if (fcntl(m_sock, F_SETFL, flags & ~O_NONBLOCK) == -1) { if (verbose) RAWLOG_ERROR1("Can not set blocking socket mode: %d", errno); return false; } #endif size_t pos = 0; for(; pos < data.size();) { int n = send(m_sock, data.c_str() + pos, data.size() - pos, 0); if (n == -1) { int e = RHO_NET_ERROR_CODE; #if !defined(WINDOWS_PLATFORM) if (e == EINTR) continue; #endif if (verbose) RAWLOG_ERROR1("Can not send response data: %d", e); return false; } if (n == 0) break; pos += n; } //String dbg_response = response.size() > 100 ? response.substr(0, 100) : response; //RAWTRACE2("Sent response:\n%s%s", dbg_response.c_str(), response.size() > 100 ? "..." : " "); if (continuation) { if (verbose) RAWTRACE1("Sent response body: %d bytes", data.size()); } else if ( !rho_conf_getBool("log_skip_post") ) { if (verbose) RAWTRACE1("Sent response (only headers displayed):\n%s", data.c_str()); } return true; } bool CHttpServer::send_response(String const &response, bool redirect) { #ifdef OS_ANDROID if (redirect) { CAutoPtr<IRhoThreadImpl> ptrThread = rho_get_RhoClassFactory()->createThreadImpl(); ptrThread->sleep(20); } #endif return send_response_impl(response, false); } String CHttpServer::create_response(String const &reason) { return create_response(reason, ""); } String CHttpServer::create_response(String const &reason, HeaderList const &headers) { return create_response(reason, headers, ""); } String CHttpServer::create_response(String const &reason, String const &body) { return create_response(reason, HeaderList(), body); } String CHttpServer::create_response(String const &reason, HeaderList const &hdrs, String const &body) { String response = "HTTP/1.1 "; response += reason; response += "\r\n"; char buf[50]; snprintf(buf, sizeof(buf), "%d", m_port); HeaderList headers; headers.push_back(Header("Host", String("127.0.0.1:") + buf)); headers.push_back(Header("Connection", "close")); headers.push_back(HttpHeader("Access-Control-Allow-Origin", "*")); std::copy(hdrs.begin(), hdrs.end(), std::back_inserter(headers)); for(HeaderList::const_iterator it = headers.begin(), lim = headers.end(); it != lim; ++it) { response += it->name; response += ": "; response += it->value; response += "\r\n"; } response += "\r\n"; response += body; return response; }
bool CHttpServer::decide(String const &method, String const &arg_uri, String const &query, HeaderList const &headers, String const &body/*, IResponseSender& respSender*/ ) { if (verbose) RAWTRACE1("Decide what to do with uri %s", arg_uri.c_str()); callback_t callback = registered(arg_uri); if (callback) { if (verbose) RAWTRACE1("Uri %s is registered callback, so handle it appropriately", arg_uri.c_str()); if ( callback == rho_http_ruby_proc_callback ) call_ruby_proc( query, body ); else callback(this, query.length() ? query : body); return false; } String uri = arg_uri; String fullPath = CFilePath::join(m_root, uri); #ifndef RHO_NO_RUBY_API if (rho_ruby_is_started()) { Route route; if (dispatch(uri, route)) { if (verbose) RAWTRACE1("Uri %s is correct route, so enable MVC logic", uri.c_str()); VALUE req = create_request_hash(route.application, route.model, route.action, route.id, method, uri, query, headers, body); VALUE data = callFramework(req); String reply(getStringFromValue(data), getStringLenFromValue(data)); rho_ruby_releaseValue(data); bool isRedirect = String_startsWith(reply, "HTTP/1.1 301") || String_startsWith(reply, "HTTP/1.1 302"); if (!send_response(reply, isRedirect)) return false; if (method == "GET") rho_rhodesapp_keeplastvisitedurl(uri.c_str()); if ( sync::RhoconnectClientManager::haveRhoconnectClientImpl() ) { if (!route.id.empty()) { sync::RhoconnectClientManager::rho_sync_addobjectnotify_bysrcname(route.model.c_str(), route.id.c_str()); } } return true; } if (isdir(fullPath)) { if (verbose) RAWTRACE1("Uri %s is directory, redirecting to index", uri.c_str()); String q = query.empty() ? "" : "?" + query; HeaderList headers; headers.push_back(Header("Location", CFilePath::join( uri, "index" RHO_ERB_EXT) + q)); send_response(create_response("301 Moved Permanently", headers), true); return false; } if (isindex(uri)) { if (!isfile(fullPath)) { if (verbose) RAWLOG_ERROR1("The file %s was not found", fullPath.c_str()); String error = "<!DOCTYPE html><html><font size=\"+4\"><h2>404 Not Found.</h2> The file " + uri + " was not found.</font></html>"; send_response(create_response("404 Not Found",error)); return false; } if (verbose) RAWTRACE1("Uri %s is index file, call serveIndex", uri.c_str()); VALUE req = create_request_hash(route.application, route.model, route.action, route.id, method, uri, query, headers, body); VALUE data = callServeIndex((char *)fullPath.c_str(), req); String reply(getStringFromValue(data), getStringLenFromValue(data)); rho_ruby_releaseValue(data); if (!send_response(reply)) return false; if (method == "GET") rho_rhodesapp_keeplastvisitedurl(uri.c_str()); return true; } } #endif // Try to send requested file if (verbose) RAWTRACE1("Uri %s should be regular file, trying to send it", uri.c_str()); PROF_START("READ_FILE"); bool bRes = send_file(uri, headers); PROF_STOP("READ_FILE"); return bRes; }
bool CHttpServer::send_file(String const &path, HeaderList const &hdrs) { String fullPath = CFilePath::normalizePath(path); if (String_startsWith(fullPath,"/app/db/db-files") ) fullPath = CFilePath::join( rho_native_rhodbpath(), path.substr(4) ); else if (fullPath.find(m_root) != 0 && fullPath.find(m_strRhoRoot) != 0 && fullPath.find(m_strRuntimeRoot) != 0 && fullPath.find(m_userroot) != 0 && fullPath.find(m_strRhoUserRoot) != 0) fullPath = CFilePath::join( m_root, path ); struct stat st; bool bCheckExist = true; #ifdef RHODES_EMULATOR String strPlatform = RHOSIMCONF().getString("platform"); if ( strPlatform.length() > 0 ) { String fullPath1 = fullPath; int nDot = fullPath1.rfind('.'); if ( nDot >= 0 ) fullPath1.insert(nDot, String(".") + strPlatform); else fullPath1 += String(".") + strPlatform; if (stat(fullPath1.c_str(), &st) == 0 && S_ISREG(st.st_mode)) { fullPath = fullPath1; bCheckExist = false; } } #endif bool doesNotExists = bCheckExist && (stat(fullPath.c_str(), &st) != 0 || !S_ISREG(st.st_mode)); if ( doesNotExists ) { // looking for files at 'rho/apps' at runtime folder fullPath = CFilePath::join( m_strRuntimeRoot, path ); } if (verbose) RAWTRACE1("Sending file %s...", fullPath.c_str()); if ( doesNotExists ) { if ( stat(fullPath.c_str(), &st) != 0 || !S_ISREG(st.st_mode) ) { doesNotExists = true; }else doesNotExists = false; } #ifdef RHODES_EMULATOR if ( doesNotExists ) { CTokenizer oTokenizer( RHOSIMCONF().getString("ext_path"), ";" ); while (oTokenizer.hasMoreTokens()) { String tok = oTokenizer.nextToken(); tok = String_trim(tok); String fullPath1 = CFilePath::join( tok, path ); if (stat(fullPath1.c_str(), &st) == 0 && S_ISREG(st.st_mode)) { fullPath = fullPath1; doesNotExists = false; break; } } } #endif if ( doesNotExists ) { if (verbose) RAWLOG_ERROR1("The file %s was not found", path.c_str()); String error = "<!DOCTYPE html><html><font size=\"+4\"><h2>404 Not Found.</h2> The file " + path + " was not found.</font></html>"; send_response(create_response("404 Not Found",error)); return false; } PROF_START("LOW_FILE"); FILE *fp = fopen(fullPath.c_str(), "rb"); PROF_STOP("LOW_FILE"); if (!fp) { if (verbose) RAWLOG_ERROR1("The file %s could not be opened", path.c_str()); String error = "<!DOCTYPE html><html><font size=\"+4\"><h2>404 Not Found.</h2> The file " + path + " could not be opened.</font></html"; send_response(create_response("404 Not Found",error)); return false; } HeaderList headers; // Detect mime type headers.push_back(Header("Content-Type", get_mime_type(path))); if ( String_startsWith(path, "/public") ) { headers.push_back(Header("Expires", "Thu, 15 Apr 2020 20:00:00 GMT") ); headers.push_back(Header("Cache-Control", "max-age=2592000") ); } // Content length char* buf = new char[FILE_BUF_SIZE]; String start_line; size_t file_size = st.st_size; size_t range_begin = 0, range_end = file_size - 1; size_t content_size = file_size; if (parse_range(hdrs, &range_begin, &range_end)) { if (range_end >= file_size) range_end = file_size - 1; if (range_begin >= range_end) range_begin = range_end - 1; content_size = range_end - range_begin + 1; if (fseek(fp, range_begin, SEEK_SET) == -1) { RAWLOG_ERROR1("Can not seek to specified range start: %lu", (unsigned long)range_begin); snprintf(buf, FILE_BUF_SIZE, "bytes */%lu", (unsigned long)file_size); headers.push_back(Header("Content-Range", buf)); send_response(create_response("416 Request Range Not Satisfiable",headers)); fclose(fp); delete[] buf; return false; } snprintf(buf, FILE_BUF_SIZE, "bytes %lu-%lu/%lu", (unsigned long)range_begin, (unsigned long)range_end, (unsigned long)file_size); headers.push_back(Header("Content-Range", buf)); start_line = "206 Partial Content"; } else { start_line = "200 OK"; } snprintf(buf, FILE_BUF_SIZE, "%lu", (unsigned long)content_size); headers.push_back(Header("Content-Length", buf)); // Send headers if (!send_response(create_response(start_line, headers))) { if (verbose) RAWLOG_ERROR1("Can not send headers while sending file %s", path.c_str()); fclose(fp); delete[] buf; return false; } // Send body for (size_t start = range_begin; start < range_end + 1;) { size_t need_to_read = range_end - start + 1; if (need_to_read == 0) break; if (need_to_read > FILE_BUF_SIZE) need_to_read = FILE_BUF_SIZE; PROF_START("LOW_FILE"); size_t n = fread(buf, 1, need_to_read, fp);//fread(buf, 1, need_to_read, fp); PROF_STOP("LOW_FILE"); if (n < need_to_read) { if (ferror(fp) ) { if (verbose) RAWLOG_ERROR2("Can not read part of file (at position %lu): %s", (unsigned long)start, strerror(errno)); } else if ( feof(fp) ) { if (verbose) RAWLOG_ERROR1("End of file reached, but we expect data (%lu bytes)", (unsigned long)need_to_read); } fclose(fp); delete[] buf; return false; } start += n; if (!send_response_body(String(buf, n))) { if (verbose) RAWLOG_ERROR1("Can not send part of data while sending file %s", path.c_str()); fclose(fp); delete[] buf; return false; } } PROF_START("LOW_FILE"); fclose(fp); PROF_STOP("LOW_FILE"); delete[] buf; if (verbose) RAWTRACE1("File %s was sent successfully", path.c_str()); return false; }
//-------------------------------------------------------------------------------------------------- RHO_GLOBAL void rho_nativethread_end(void *) { RAWTRACE1("Thread ended - env: 0x%.8x ===================================================", jnienv()); jvm()->DetachCurrentThread(); store_thr_jnienv(0); }
bool CHttpServer::decide(String const &method, String const &arg_uri, String const &query, HeaderList const &headers, String const &body) { RAWTRACE1("Decide what to do with uri %s", arg_uri.c_str()); callback_t callback = registered(arg_uri); if (callback) { RAWTRACE1("Uri %s is registered callback, so handle it appropriately", arg_uri.c_str()); if ( callback == rho_http_ruby_proc_callback ) call_ruby_proc( query, body ); else callback(this, query.length() ? query : body); return false; } String uri = arg_uri; //#ifdef OS_ANDROID // //Work around malformed Android WebView URLs // if (!String_startsWith(uri, "/app") && // !String_startsWith(uri, "/public") && // !String_startsWith(uri, "/data")) // { // RAWTRACE1("Malformed URL: '%s', adding '/app' prefix.", uri.c_str()); // uri = CFilePath::join("/app", uri); // } //#endif String fullPath = CFilePath::join(m_root, uri); Route route; if (dispatch(uri, route)) { RAWTRACE1("Uri %s is correct route, so enable MVC logic", uri.c_str()); VALUE req = create_request_hash(route.application, route.model, route.action, route.id, method, uri, query, headers, body); VALUE data = callFramework(req); String reply(getStringFromValue(data), getStringLenFromValue(data)); rho_ruby_releaseValue(data); bool isRedirect = String_startsWith(reply, "HTTP/1.1 301") || String_startsWith(reply, "HTTP/1.1 302"); if (!send_response(reply, isRedirect)) return false; if (method == "GET") rho_rhodesapp_keeplastvisitedurl(uri.c_str()); if ( sync::RhoconnectClientManager::haveRhoconnectClientImpl() ) { if (!route.id.empty()) { sync::RhoconnectClientManager::rho_sync_addobjectnotify_bysrcname(route.model.c_str(), route.id.c_str()); } } return true; } //#ifndef OS_ANDROID if (isdir(fullPath)) { RAWTRACE1("Uri %s is directory, redirecting to index", uri.c_str()); String q = query.empty() ? "" : "?" + query; HeaderList headers; headers.push_back(Header("Location", CFilePath::join( uri, "index"RHO_ERB_EXT) + q)); send_response(create_response("301 Moved Permanently", headers), true); return false; } //#else // //Work around this Android redirect bug: // //http://code.google.com/p/android/issues/detail?can=2&q=11583&id=11583 // if (isdir(fullPath)) { // RAWTRACE1("Uri %s is directory, override with index", uri.c_str()); // return decide(method, CFilePath::join( uri, "index"RHO_ERB_EXT), query, headers, body); // } //#endif if (isindex(uri)) { if (!isfile(fullPath)) { RAWLOG_ERROR1("The file %s was not found", fullPath.c_str()); String error = "<html><font size=\"+4\"><h2>404 Not Found.</h2> The file " + uri + " was not found.</font></html>"; send_response(create_response("404 Not Found",error)); return false; } RAWTRACE1("Uri %s is index file, call serveIndex", uri.c_str()); VALUE req = create_request_hash(route.application, route.model, route.action, route.id, method, uri, query, headers, body); VALUE data = callServeIndex((char *)fullPath.c_str(), req); String reply(getStringFromValue(data), getStringLenFromValue(data)); rho_ruby_releaseValue(data); if (!send_response(reply)) return false; if (method == "GET") rho_rhodesapp_keeplastvisitedurl(uri.c_str()); return true; } // Try to send requested file RAWTRACE1("Uri %s should be regular file, trying to send it", uri.c_str()); return send_file(uri, headers); }
int Curl_resolv(struct connectdata *conn, const char *hostname, int port, struct Curl_dns_entry **entry) { char *entry_id = NULL; struct Curl_dns_entry *dns = NULL; size_t entry_len; struct SessionHandle *data = conn->data; CURLcode result; int rc = CURLRESOLV_ERROR; /* default to failure */ *entry = NULL; /* Create an entry id, based upon the hostname and port */ entry_id = create_hostcache_id(hostname, port); /* If we can't create the entry id, fail */ if(!entry_id) return rc; RAWTRACE1("Curl_resolv host: cache_id: %s", entry_id); entry_len = strlen(entry_id); if(data->share) Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE); /* See if its already in our dns cache */ dns = Curl_hash_pick(data->dns.hostcache, entry_id, entry_len+1); /* See whether the returned entry is stale. Done before we release lock */ if( remove_entry_if_stale(data, dns) ) dns = NULL; /* the memory deallocation is being handled by the hash */ if(dns) { dns->inuse++; /* we use it! */ rc = CURLRESOLV_RESOLVED; } if(data->share) Curl_share_unlock(data, CURL_LOCK_DATA_DNS); /* free the allocated entry_id again */ free(entry_id); if(!dns) { /* The entry was not in the cache. Resolve it to IP address */ Curl_addrinfo *addr; int respwait; /* Check what IP specifics the app has requested and if we can provide it. * If not, bail out. */ if(!Curl_ipvalid(data)) return CURLRESOLV_ERROR; /* If Curl_getaddrinfo() returns NULL, 'respwait' might be set to a non-zero value indicating that we need to wait for the response to the resolve call */ addr = Curl_getaddrinfo(conn, #ifdef DEBUGBUILD (data->set.str[STRING_DEVICE] && !strcmp(data->set.str[STRING_DEVICE], "LocalHost"))?"localhost": #endif hostname, port, &respwait); if(!addr) { if(respwait) { /* the response to our resolve call will come asynchronously at a later time, good or bad */ /* First, check that we haven't received the info by now */ result = Curl_is_resolved(conn, &dns); if(result) /* error detected */ return CURLRESOLV_ERROR; if(dns) rc = CURLRESOLV_RESOLVED; /* pointer provided */ else rc = CURLRESOLV_PENDING; /* no info yet */ } } else { if(data->share) Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE); /* we got a response, store it in the cache */ dns = Curl_cache_addr(data, addr, hostname, port); if(data->share) Curl_share_unlock(data, CURL_LOCK_DATA_DNS); if(!dns) /* returned failure, bail out nicely */ Curl_freeaddrinfo(addr); else rc = CURLRESOLV_RESOLVED; } } *entry = dns; return rc; }