void securid_session_free(rlm_securid_t *inst,REQUEST *request, SECURID_SESSION *session) { if (!session) return; RDEBUG2("Freeing session id=%d identity='%s' state='%s'", session->session_id,SAFE_STR(session->identity),session->state); if (session->identity) { free(session->identity); session->identity = NULL; } if (session->pin) { free(session->pin); session->pin = NULL; } if (session->sdiHandle != SDI_HANDLE_NONE) { SD_Close(session->sdiHandle); session->sdiHandle = SDI_HANDLE_NONE; } free(session); }
/* * Find existing session if any which matches the State variable in current AccessRequest * Then, release the session from the list, and return it to * the caller. * */ SECURID_SESSION *securid_sessionlist_find(rlm_securid_t *inst, REQUEST *request) { VALUE_PAIR *state; SECURID_SESSION* session; SECURID_SESSION mySession; /* clean expired sessions if any */ pthread_mutex_lock(&(inst->session_mutex)); securid_sessionlist_clean_expired(inst, request, request->timestamp); pthread_mutex_unlock(&(inst->session_mutex)); /* * We key the sessions off of the 'state' attribute */ state = pairfind(request->packet->vps, PW_STATE, 0, TAG_ANY); if (!state) { return NULL; } if (state->length != SECURID_STATE_LEN) { radlog(L_ERR,"rlm_securid: Invalid State variable. length=%d",state->length); return NULL; } memset(&mySession,0,sizeof(mySession)); mySession.src_ipaddr = request->packet->src_ipaddr; memcpy(mySession.state, state->vp_strvalue, sizeof(mySession.state)); /* * Playing with a data structure shared among threads * means that we need a lock, to avoid conflict. */ pthread_mutex_lock(&(inst->session_mutex)); session = securid_sessionlist_delete(inst, &mySession); pthread_mutex_unlock(&(inst->session_mutex)); /* * Might not have been there. */ if (!session) { radlog(L_ERR,"rlm_securid: No SECURID session matching the State variable."); return NULL; } RDEBUG2("Session found identity='%s' state='%s', released from the list", SAFE_STR(session->identity),session->state); if (session->trips >= inst->max_trips_per_session) { RDEBUG2("More than %d authentication packets for this SECURID session. Aborted.",inst->max_trips_per_session); securid_session_free(inst,request,session); return NULL; } session->trips++; return session; }
static const char *roadmap_splash_get_splash_name(BOOL wide){ unsigned int i; const char *splash_file = NULL; int width = roadmap_canvas_width(); int height = roadmap_canvas_height(); if ((height < width) && !wide){ width = height; height = roadmap_canvas_width(); } else if ((width < height) && wide){ width = height; height = roadmap_canvas_width(); } for (i=0; i<sizeof(RoadMapSplashFiles)/sizeof(RoadMapSplashFiles[0]); i++) { if ((width >= RoadMapSplashFiles[i].min_screen_width) && (wide == RoadMapSplashFiles[i].is_wide)) { if ((RoadMapSplashFiles[i].height != -1) ){ if (RoadMapSplashFiles[i].height == height){ splash_file = RoadMapSplashFiles[i].name; break; } } else{ splash_file = RoadMapSplashFiles[i].name; break; } } } if (!splash_file) { static char file_name[50]; static char file_name_wide[50]; roadmap_log (ROADMAP_ERROR, "Can't find splash file for screen width: %d height: %d (wide =%d)", width, height, wide); if (wide){ sprintf(file_name_wide, "welcome_wide_%d_%d",width, height); return &file_name_wide[0]; }else{ sprintf(file_name,"welcome_%d_%d",width, height); return &file_name[0]; } } // Remove this when splash bug will be fixed roadmap_log( ROADMAP_WARNING, "Downloading splash file: %s. Canvas: (%d, %d)", SAFE_STR( splash_file ), roadmap_canvas_width(), roadmap_canvas_height() ); return splash_file; }
static void securid_sessionlist_clean_expired(rlm_securid_t *inst, REQUEST *request, time_t timestamp) { int num_sessions; SECURID_SESSION *session; num_sessions = rbtree_num_elements(inst->session_tree); RDEBUG2("There are %d sessions in the tree\n",num_sessions); /* * Delete old sessions from the list * */ while((session = inst->session_head)) { if ((timestamp - session->timestamp) > inst->timer_limit) { rbnode_t *node; node = rbtree_find(inst->session_tree, session); rad_assert(node != NULL); rbtree_delete(inst->session_tree, node); /* * session == inst->session_head */ inst->session_head = session->next; if (session->next) { session->next->prev = NULL; } else { inst->session_head = NULL; inst->session_tail = NULL; } RDEBUG2("Cleaning expired session: identity='%s' state='%s'\n", SAFE_STR(session->identity),session->state); securid_session_free(inst,request,session); } else { /* no need to check all sessions since they are sorted by age */ break; } } }
void tts_set_voice( const char* voice_id ) { const TtsProvider* provider; if ( !tts_feature_enabled() ) return; if ( !voice_id || ( sgActiveProvider && !strcmp( voice_id, sgTtsVoiceId ) ) ) return; roadmap_log( ROADMAP_INFO, TTS_LOG_STR( "Voice change request: %s => %s" ), SAFE_STR( sgTtsVoiceId ), SAFE_STR( voice_id ) ); // Find active provider if ( !( provider = _voice_service_provider( voice_id ) ) ) { roadmap_log( ROADMAP_ERROR, TTS_LOG_STR( "Critical TTS Engine error. Provider is not registered for voice id: %s." ), sgTtsVoiceId ); return; } if ( !TTS_VOICE_VALID( tts_voices_get( voice_id, NULL ) ) ) { roadmap_log( ROADMAP_WARNING, TTS_LOG_STR( "Current voice %s is not valid. Server may not support the requests" ), voice_id ); } sgActiveProvider = provider; sgActiveRequestsCount = 0; if ( sgActiveProvider->prepare_cb ) sgActiveProvider->prepare_cb(); sgTtsVoiceId = voice_id; tts_cache_set_voice( sgTtsVoiceId, sgActiveProvider->storage_type ); roadmap_config_set( &RMConfigTTSVoiceId, sgTtsVoiceId ); _voice_changed( sgTtsVoiceId, FALSE ); }
/* * Add a session to the set of active sessions. * * Since we're adding it to the list, we guess that this means * the packet needs a State attribute. So add one. */ int securid_sessionlist_add(rlm_securid_t *inst,REQUEST *request, SECURID_SESSION *session) { int status = 0; VALUE_PAIR *state; rad_assert(session != NULL); rad_assert(request != NULL); /* * The time at which this request was made was the time * at which it was received by the RADIUS server. */ session->timestamp = request->timestamp; session->src_ipaddr = request->packet->src_ipaddr; /* * Playing with a data structure shared among threads * means that we need a lock, to avoid conflict. */ pthread_mutex_lock(&(inst->session_mutex)); /* * If we have a DoS attack, discard new sessions. */ if (rbtree_num_elements(inst->session_tree) >= inst->max_sessions) { securid_sessionlist_clean_expired(inst, request, session->timestamp); goto done; } if (session->session_id == 0) { /* this is a NEW session (we are not inserting an updated session) */ inst->last_session_id++; session->session_id = inst->last_session_id; RDEBUG2("Creating a new session with id=%d\n",session->session_id); } snprintf(session->state,sizeof(session->state)-1,"FRR-CH %d|%d",session->session_id,session->trips+1); RDEBUG2("Inserting session id=%d identity='%s' state='%s' to the session list", session->session_id,SAFE_STR(session->identity),session->state); /* * Generate State, since we've been asked to add it to * the list. */ state = pairmake("State", session->state, T_OP_EQ); if (!state) return -1; state->length = SECURID_STATE_LEN; status = rbtree_insert(inst->session_tree, session); if (status) { /* tree insert SUCCESS */ /* insert the session to the linked list of sessions */ SECURID_SESSION *prev; prev = inst->session_tail; if (prev) { /* insert to the tail of the list */ prev->next = session; session->prev = prev; session->next = NULL; inst->session_tail = session; } else { /* 1st time */ inst->session_head = inst->session_tail = session; session->next = session->prev = NULL; } } /* * Now that we've finished mucking with the list, * unlock it. */ done: pthread_mutex_unlock(&(inst->session_mutex)); if (!status) { pairfree(&state); radlog(L_ERR, "rlm_securid: Failed to store session"); return -1; } pairadd(&(request->reply->vps), state); return 0; }
static SECURID_AUTH_RC securidAuth(void *instance, REQUEST *request, const char* username, const char* passcode, char* replyMsgBuffer,int replyMsgBufferSize) { rlm_securid_t *inst = (rlm_securid_t *) instance; int acmRet; SD_PIN pinParams; char newPin[10]; char format[30]; SECURID_SESSION *pSecurid_session=NULL; int rc=-1; if (!username) { radlog(L_ERR, "SecurID username is NULL"); return RC_SECURID_AUTH_FAILURE; } if (!passcode) { radlog(L_ERR, "SecurID passcode is NULL for %s user",username); return RC_SECURID_AUTH_FAILURE; } *replyMsgBuffer = '\0'; pSecurid_session = securid_sessionlist_find(inst,request); if (pSecurid_session == NULL) { /* securid session not found */ SDI_HANDLE sdiHandle = SDI_HANDLE_NONE; acmRet = SD_Init(&sdiHandle); if (acmRet != ACM_OK) { radlog(L_ERR, "Cannot communicate with the ACE/Server"); return -1; } acmRet = SD_Lock(sdiHandle, (SD_CHAR*)username); if (acmRet != ACM_OK) { radlog(L_ERR,"SecurID: Access denied. Name [%s] lock failed.",username); return -2; } acmRet = SD_Check(sdiHandle, (SD_CHAR*) passcode, (SD_CHAR*) username); switch (acmRet) { case ACM_OK: /* we are in now */ RDEBUG("SecurID authentication successful for %s.", username); SD_Close(sdiHandle); return RC_SECURID_AUTH_SUCCESS; case ACM_ACCESS_DENIED: /* not this time */ RDEBUG("SecurID Access denied for %s", username); SD_Close(sdiHandle); return RC_SECURID_AUTH_ACCESS_DENIED_FAILURE; case ACM_INVALID_SERVER: radlog(L_ERR,"SecurID: Invalid ACE server."); return RC_SECURID_AUTH_INVALID_SERVER_FAILURE; case ACM_NEW_PIN_REQUIRED: RDEBUG2("SeecurID new pin required for %s", username); /* create a new session */ pSecurid_session = securid_session_alloc(); pSecurid_session->sdiHandle = sdiHandle; /* save ACE handle for future use */ pSecurid_session->securidSessionState = NEW_PIN_REQUIRED_STATE; pSecurid_session->identity = strdup(username); /* Get PIN requirements */ acmRet = AceGetPinParams(sdiHandle, &pinParams); /* If a system-generated PIN is required */ if (pinParams.Selectable == CANNOT_CHOOSE_PIN) { /* Prompt user to accept a system generated PIN */ snprintf(replyMsgBuffer, replyMsgBufferSize, "\r\nAre you prepared to accept a new system-generated PIN [y/n]?"); pSecurid_session->securidSessionState = NEW_PIN_SYSTEM_ACCEPT_STATE; } else if (pinParams.Selectable == USER_SELECTABLE) { //may be returned by AM 6.x servers. snprintf(replyMsgBuffer, replyMsgBufferSize, "\r\nPress 'y' to generate a new PIN\r\nOR\r\n'n'to enter a new PIN yourself [y/n]"); pSecurid_session->securidSessionState = NEW_PIN_USER_SELECT_STATE; } else { if (pinParams.Alphanumeric) { strcpy(format, "alphanumeric characters"); } else { strcpy(format, "digits"); } snprintf(replyMsgBuffer, replyMsgBufferSize, " \r\n Enter your new PIN of %d to %d %s,\r\n or\r\n <Ctrl-D> to cancel the New PIN procedure:", pinParams.Min, pinParams.Max, format); } /* insert new session in the session list */ securid_sessionlist_add(inst,request,pSecurid_session); return RC_SECURID_AUTH_CHALLENGE; case ACM_NEXT_CODE_REQUIRED: RDEBUG2("Next securid token code required for %s", username); /* create a new session */ pSecurid_session = securid_session_alloc(); pSecurid_session->sdiHandle = sdiHandle; pSecurid_session->securidSessionState = NEXT_CODE_REQUIRED_STATE; pSecurid_session->identity = strdup(username); /* insert new session in the session list */ securid_sessionlist_add(inst,request,pSecurid_session); strlcpy(replyMsgBuffer, "\r\nPlease Enter the Next Code from Your Token:", replyMsgBufferSize); return RC_SECURID_AUTH_CHALLENGE; default: radlog(L_ERR,"SecurID: Unexpected error from ACE/Agent API acmRet=%d",acmRet); return RC_SECURID_AUTH_FAILURE; } } else { /* existing session found */ RDEBUG("Continuing previous session found for user [%s]",username); /* continue previous session */ switch (pSecurid_session->securidSessionState) { case NEXT_CODE_REQUIRED_STATE: DEBUG2("Securid NEXT_CODE_REQUIRED_STATE: User [%s]",username); /* next token code mode */ acmRet = SD_Next(pSecurid_session->sdiHandle, (SD_CHAR*)passcode); if (acmRet == ACM_OK) { radlog(L_INFO,"Next SecurID token accepted for [%s].",pSecurid_session->identity); rc = RC_SECURID_AUTH_SUCCESS; } else { radlog(L_INFO,"SecurID: Next token rejected for [%s].",pSecurid_session->identity); rc = RC_SECURID_AUTH_FAILURE; } /* deallocate session */ securid_session_free(inst,request,pSecurid_session); return rc; case NEW_PIN_REQUIRED_STATE: RDEBUG2("SecurID NEW_PIN_REQUIRED_STATE for %s", username); /* save the previous pin */ if (pSecurid_session->pin) { free(pSecurid_session->pin); pSecurid_session->pin = NULL; } pSecurid_session->pin = strdup(passcode); strlcpy(replyMsgBuffer,"\r\n Please re-enter new PIN:", replyMsgBufferSize); /* set next state */ pSecurid_session->securidSessionState = NEW_PIN_USER_CONFIRM_STATE; /* insert the updated session in the session list */ securid_sessionlist_add(inst,request,pSecurid_session); return RC_SECURID_AUTH_CHALLENGE; case NEW_PIN_USER_CONFIRM_STATE: RDEBUG2("SecurID NEW_PIN_USER_CONFIRM_STATE: User [%s]",username); /* compare previous pin and current pin */ if (!pSecurid_session->pin || strcmp(pSecurid_session->pin,passcode)) { RDEBUG2("Pin confirmation failed. Pins do not match [%s] and [%s]", SAFE_STR(pSecurid_session->pin), passcode); /* pins do not match */ /* challenge the user again */ AceGetPinParams(pSecurid_session->sdiHandle, &pinParams); if (pinParams.Alphanumeric) { strcpy(format, "alphanumeric characters"); } else { strcpy(format, "digits"); } snprintf(replyMsgBuffer, replyMsgBufferSize, " \r\n Pins do not match--Please try again.\r\n Enter your new PIN of %d to %d %s,\r\n or\r\n <Ctrl-D> to cancel the New PIN procedure:", pinParams.Min, pinParams.Max, format); pSecurid_session->securidSessionState = NEW_PIN_REQUIRED_STATE; /* insert the updated session in the session list */ securid_sessionlist_add(inst,request,pSecurid_session); rc = RC_SECURID_AUTH_CHALLENGE; } else { /* pins match */ RDEBUG2("Pin confirmation succeeded. Pins match"); acmRet = SD_Pin(pSecurid_session->sdiHandle, (SD_CHAR*)passcode); if (acmRet == ACM_NEW_PIN_ACCEPTED) { RDEBUG("New SecurID pin accepted for %s.",pSecurid_session->identity); pSecurid_session->securidSessionState = NEW_PIN_AUTH_VALIDATE_STATE; /* insert the updated session in the session list */ securid_sessionlist_add(inst,request,pSecurid_session); rc = RC_SECURID_AUTH_CHALLENGE; strlcpy(replyMsgBuffer," \r\n\r\nWait for the code on your card to change, then enter new PIN and TokenCode\r\n\r\nEnter PASSCODE:", replyMsgBufferSize); } else { RDEBUG("SecurID: New SecurID pin rejected for %s.",pSecurid_session->identity); SD_Pin(pSecurid_session->sdiHandle, (SD_CHAR*)""); /* cancel PIN */ rc = RC_SECURID_AUTH_FAILURE; /* deallocate session */ securid_session_free(inst, request, pSecurid_session); } } return rc; case NEW_PIN_AUTH_VALIDATE_STATE: acmRet = SD_Check(pSecurid_session->sdiHandle, (SD_CHAR*)passcode, (SD_CHAR*)username); if (acmRet == ACM_OK) { RDEBUG("New SecurID passcode accepted for %s.", pSecurid_session->identity); rc = RC_SECURID_AUTH_SUCCESS; } else { radlog(L_INFO,"SecurID: New passcode rejected for [%s].",pSecurid_session->identity); rc = RC_SECURID_AUTH_FAILURE; } /* deallocate session */ securid_session_free(inst,request,pSecurid_session); return rc; case NEW_PIN_SYSTEM_ACCEPT_STATE: if (!strcmp(passcode, "y")) { AceGetSystemPin(pSecurid_session->sdiHandle, newPin); /* Save the PIN for the next session * continuation */ if (pSecurid_session->pin) { free(pSecurid_session->pin); pSecurid_session->pin = NULL; } pSecurid_session->pin = strdup(newPin); snprintf(replyMsgBuffer, replyMsgBufferSize, "\r\nYour new PIN is: %s\r\nDo you accept this [y/n]?", newPin); pSecurid_session->securidSessionState = NEW_PIN_SYSTEM_CONFIRM_STATE; /* insert the updated session in the * session list */ securid_sessionlist_add(inst, request, pSecurid_session); rc = RC_SECURID_AUTH_CHALLENGE; } else { SD_Pin(pSecurid_session->sdiHandle, (SD_CHAR*)""); //Cancel new PIN /* deallocate session */ securid_session_free(inst, request, pSecurid_session); rc = RC_SECURID_AUTH_FAILURE; } return rc; case NEW_PIN_SYSTEM_CONFIRM_STATE: acmRet = SD_Pin(pSecurid_session->sdiHandle, (SD_CHAR*)pSecurid_session->pin); if (acmRet == ACM_NEW_PIN_ACCEPTED) { strlcpy(replyMsgBuffer," \r\n\r\nPin Accepted. Wait for the code on your card to change, then enter new PIN and TokenCode\r\n\r\nEnter PASSCODE:",replyMsgBufferSize); pSecurid_session->securidSessionState = NEW_PIN_AUTH_VALIDATE_STATE; /* insert the updated session in the session list */ securid_sessionlist_add(inst,request,pSecurid_session); rc = RC_SECURID_AUTH_CHALLENGE; } else { SD_Pin(pSecurid_session->sdiHandle, (SD_CHAR*)""); //Cancel new PIN strlcpy(replyMsgBuffer," \r\n\r\nPin Rejected. Wait for the code on your card to change, then try again.\r\n\r\nEnter PASSCODE:",replyMsgBufferSize); /* deallocate session */ securid_session_free(inst, request, pSecurid_session); rc = RC_SECURID_AUTH_FAILURE; } return rc; /* USER_SELECTABLE state should be implemented to preserve compatibility with AM 6.x servers, which can return this state */ case NEW_PIN_USER_SELECT_STATE: if (!strcmp(passcode, "y")) { /* User has opted for a system-generated PIN */ AceGetSystemPin(pSecurid_session->sdiHandle, newPin); snprintf(replyMsgBuffer, replyMsgBufferSize, "\r\nYour new PIN is: %s\r\nDo you accept this [y/n]?", newPin); pSecurid_session->securidSessionState = NEW_PIN_SYSTEM_CONFIRM_STATE; /* insert the updated session in the session list */ securid_sessionlist_add(inst, request, pSecurid_session); rc = RC_SECURID_AUTH_CHALLENGE; } else { /* User has opted for a user-defined PIN */ AceGetPinParams(pSecurid_session->sdiHandle, &pinParams); if (pinParams.Alphanumeric) { strcpy(format, "alphanumeric characters"); } else { strcpy(format, "digits"); } snprintf(replyMsgBuffer, replyMsgBufferSize, " \r\n Enter your new PIN of %d to %d %s,\r\n or\r\n <Ctrl-D> to cancel the New PIN procedure:", pinParams.Min, pinParams.Max, format); pSecurid_session->securidSessionState = NEW_PIN_REQUIRED_STATE; /* insert the updated session in the session list */ securid_sessionlist_add(inst, request, pSecurid_session); rc = RC_SECURID_AUTH_CHALLENGE; } return rc; default: radlog(L_ERR|L_CONS, "rlm_securid: Invalid session state %d for user [%s]", pSecurid_session->securidSessionState, username); break; } } return 0; }
PHP_METHOD(DefaultCluster, connect) { CassFuture* future = NULL; char* hash_key; int hash_key_len = 0; char* keyspace = NULL; int keyspace_len; zval* timeout = NULL; cassandra_psession* psession; cassandra_cluster* cluster = NULL; cassandra_session* session = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sz", &keyspace, &keyspace_len, &timeout) == FAILURE) { return; } cluster = (cassandra_cluster*) zend_object_store_get_object(getThis() TSRMLS_CC); object_init_ex(return_value, cassandra_default_session_ce); session = (cassandra_session*) zend_object_store_get_object(return_value TSRMLS_CC); session->default_consistency = cluster->default_consistency; session->default_page_size = cluster->default_page_size; session->default_timeout = cluster->default_timeout; session->persist = cluster->persist; if (session->default_timeout) { Z_ADDREF_P(session->default_timeout); } if (session->persist) { zend_rsrc_list_entry *le; hash_key_len = spprintf(&hash_key, 0, "%s:session:%s", cluster->hash_key, SAFE_STR(keyspace)); if (zend_hash_find(&EG(persistent_list), hash_key, hash_key_len + 1, (void **)&le) == SUCCESS && Z_TYPE_P(le) == php_le_cassandra_session()) { psession = (cassandra_psession*) le->ptr; session->session = psession->session; future = psession->future; } } if (future == NULL) { session->session = cass_session_new(); if (keyspace) { future = cass_session_connect_keyspace(session->session, cluster->cluster, keyspace); } else { future = cass_session_connect(session->session, cluster->cluster); } if (session->persist) { zend_rsrc_list_entry pe; psession = (cassandra_psession*) pecalloc(1, sizeof(cassandra_psession), 1); psession->session = session->session; psession->future = future; pe.type = php_le_cassandra_session(); pe.ptr = psession; zend_hash_update(&EG(persistent_list), hash_key, hash_key_len + 1, &pe, sizeof(zend_rsrc_list_entry), NULL); CASSANDRA_G(persistent_sessions)++; } } if (php_cassandra_future_wait_timed(future, timeout TSRMLS_CC) == FAILURE) { if (session->persist) { efree(hash_key); } else { cass_future_free(future); } return; } if (php_cassandra_future_is_error(future TSRMLS_CC) == FAILURE) { if (session->persist) { if (zend_hash_del(&EG(persistent_list), hash_key, hash_key_len + 1) == SUCCESS) { session->session = NULL; } efree(hash_key); } else { cass_future_free(future); } return; } if (session->persist) efree(hash_key); }
PHP_METHOD(DefaultCluster, connectAsync) { char* hash_key; int hash_key_len = 0; char* keyspace = NULL; int keyspace_len; cassandra_cluster* cluster = NULL; cassandra_future_session* future = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &keyspace, &keyspace_len) == FAILURE) { return; } cluster = (cassandra_cluster*) zend_object_store_get_object(getThis() TSRMLS_CC); object_init_ex(return_value, cassandra_future_session_ce); future = (cassandra_future_session*) zend_object_store_get_object(return_value TSRMLS_CC); future->persist = cluster->persist; if (cluster->persist) { zend_rsrc_list_entry *le; hash_key_len = spprintf(&hash_key, 0, "%s:session:%s", cluster->hash_key, SAFE_STR(keyspace)); future->hash_key = hash_key; future->hash_key_len = hash_key_len; if (zend_hash_find(&EG(persistent_list), hash_key, hash_key_len + 1, (void **)&le) == SUCCESS) { if (Z_TYPE_P(le) == php_le_cassandra_session()) { cassandra_psession* psession = (cassandra_psession*) le->ptr; future->session = psession->session; future->future = psession->future; return; } } } future->session = cass_session_new(); if (keyspace) { future->future = cass_session_connect_keyspace(future->session, cluster->cluster, keyspace); } else { future->future = cass_session_connect(future->session, cluster->cluster); } if (cluster->persist) { zend_rsrc_list_entry le; cassandra_psession* psession = (cassandra_psession*) pecalloc(1, sizeof(cassandra_psession), 1); psession->session = future->session; psession->future = future->future; le.type = php_le_cassandra_session(); le.ptr = psession; zend_hash_update(&EG(persistent_list), hash_key, hash_key_len + 1, &le, sizeof(zend_rsrc_list_entry), NULL); CASSANDRA_G(persistent_sessions)++; } }
void mysqli_common_connect(INTERNAL_FUNCTION_PARAMETERS, zend_bool is_real_connect, zend_bool in_ctor) /* {{{ */ { MY_MYSQL *mysql = NULL; MYSQLI_RESOURCE *mysqli_resource = NULL; zval *object = getThis(); char *hostname = NULL, *username=NULL, *passwd=NULL, *dbname=NULL, *socket=NULL; size_t hostname_len = 0, username_len = 0, passwd_len = 0, dbname_len = 0, socket_len = 0; zend_bool persistent = FALSE; zend_long port = 0, flags = 0; zend_string *hash_key = NULL; zend_bool new_connection = FALSE; zend_resource *le; mysqli_plist_entry *plist = NULL; zend_bool self_alloced = 0; #if !defined(MYSQL_USE_MYSQLND) if ((MYSQL_VERSION_ID / 100) != (mysql_get_client_version() / 100)) { php_error_docref(NULL, E_WARNING, "Headers and client library minor version mismatch. Headers:%d Library:%ld", MYSQL_VERSION_ID, mysql_get_client_version()); } #endif if (getThis() && !ZEND_NUM_ARGS() && in_ctor) { php_mysqli_init(INTERNAL_FUNCTION_PARAM_PASSTHRU, in_ctor); return; } hostname = username = dbname = passwd = socket = NULL; if (!is_real_connect) { if (zend_parse_parameters(ZEND_NUM_ARGS(), "|ssssls", &hostname, &hostname_len, &username, &username_len, &passwd, &passwd_len, &dbname, &dbname_len, &port, &socket, &socket_len) == FAILURE) { return; } if (object && instanceof_function(Z_OBJCE_P(object), mysqli_link_class_entry)) { mysqli_resource = (Z_MYSQLI_P(object))->ptr; if (mysqli_resource && mysqli_resource->ptr) { mysql = (MY_MYSQL*) mysqli_resource->ptr; } } if (!mysql) { mysql = (MY_MYSQL *) ecalloc(1, sizeof(MY_MYSQL)); self_alloced = 1; } flags |= CLIENT_MULTI_RESULTS; /* needed for mysql_multi_query() */ } else { /* We have flags too */ if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O|sssslsl", &object, mysqli_link_class_entry, &hostname, &hostname_len, &username, &username_len, &passwd, &passwd_len, &dbname, &dbname_len, &port, &socket, &socket_len, &flags) == FAILURE) { return; } mysqli_resource = (Z_MYSQLI_P(object))->ptr; MYSQLI_FETCH_RESOURCE_CONN(mysql, object, MYSQLI_STATUS_INITIALIZED); /* set some required options */ flags |= CLIENT_MULTI_RESULTS; /* needed for mysql_multi_query() */ /* remove some insecure options */ flags &= ~CLIENT_MULTI_STATEMENTS; /* don't allow multi_queries via connect parameter */ #if !defined(MYSQLI_USE_MYSQLND) if (PG(open_basedir) && PG(open_basedir)[0] != '\0') { flags &= ~CLIENT_LOCAL_FILES; } #endif } if (!socket_len || !socket) { socket = MyG(default_socket); } if (!port){ port = MyG(default_port); } if (!passwd) { passwd = MyG(default_pw); passwd_len = strlen(SAFE_STR(passwd)); } if (!username){ username = MyG(default_user); } if (!hostname || !hostname_len) { hostname = MyG(default_host); } if (mysql->mysql && mysqli_resource && (mysqli_resource->status > MYSQLI_STATUS_INITIALIZED)) { /* already connected, we should close the connection */ php_mysqli_close(mysql, MYSQLI_CLOSE_IMPLICIT, mysqli_resource->status); } if (strlen(SAFE_STR(hostname)) > 2 && !strncasecmp(hostname, "p:", 2)) { hostname += 2; if (!MyG(allow_persistent)) { php_error_docref(NULL, E_WARNING, "Persistent connections are disabled. Downgrading to normal"); } else { mysql->persistent = persistent = TRUE; hash_key = strpprintf(0, "mysqli_%s_%s" ZEND_LONG_FMT "%s%s%s", SAFE_STR(hostname), SAFE_STR(socket), port, SAFE_STR(username), SAFE_STR(dbname), SAFE_STR(passwd)); mysql->hash_key = hash_key; /* check if we can reuse existing connection ... */ if ((le = zend_hash_find_ptr(&EG(persistent_list), hash_key)) != NULL) { if (le->type == php_le_pmysqli()) { plist = (mysqli_plist_entry *) le->ptr; do { if (zend_ptr_stack_num_elements(&plist->free_links)) { mysql->mysql = zend_ptr_stack_pop(&plist->free_links); MyG(num_inactive_persistent)--; /* reset variables */ #ifndef MYSQLI_NO_CHANGE_USER_ON_PCONNECT if (!mysqli_change_user_silent(mysql->mysql, username, passwd, dbname, passwd_len)) { #else if (!mysql_ping(mysql->mysql)) { #endif #ifdef MYSQLI_USE_MYSQLND mysqlnd_restart_psession(mysql->mysql); #endif MyG(num_active_persistent)++; /* clear error */ php_mysqli_set_error(mysql_errno(mysql->mysql), (char *) mysql_error(mysql->mysql)); goto end; } else { mysqli_close(mysql->mysql, MYSQLI_CLOSE_IMPLICIT); mysql->mysql = NULL; } } } while (0); } } else { plist = calloc(1, sizeof(mysqli_plist_entry)); zend_ptr_stack_init_ex(&plist->free_links, 1); zend_register_persistent_resource(ZSTR_VAL(hash_key), ZSTR_LEN(hash_key), plist, php_le_pmysqli()); } }
PHP_METHOD(DefaultCluster, connect) { CassFuture *future = NULL; char *hash_key; php5to7_size hash_key_len = 0; char *keyspace = NULL; php5to7_size keyspace_len; zval *timeout = NULL; cassandra_psession *psession; cassandra_cluster *cluster = NULL; cassandra_session *session = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sz", &keyspace, &keyspace_len, &timeout) == FAILURE) { return; } cluster = PHP_CASSANDRA_GET_CLUSTER(getThis()); object_init_ex(return_value, cassandra_default_session_ce); session = PHP_CASSANDRA_GET_SESSION(return_value); session->default_consistency = cluster->default_consistency; session->default_page_size = cluster->default_page_size; session->persist = cluster->persist; if (!PHP5TO7_ZVAL_IS_UNDEF(session->default_timeout)) { PHP5TO7_ZVAL_COPY(PHP5TO7_ZVAL_MAYBE_P(session->default_timeout), PHP5TO7_ZVAL_MAYBE_P(cluster->default_timeout)); } if (session->persist) { php5to7_zend_resource_le *le; hash_key_len = spprintf(&hash_key, 0, "%s:session:%s", cluster->hash_key, SAFE_STR(keyspace)); if (PHP5TO7_ZEND_HASH_FIND(&EG(persistent_list), hash_key, hash_key_len + 1, le) && Z_RES_P(le)->type == php_le_cassandra_session()) { psession = (cassandra_psession *) Z_RES_P(le)->ptr; session->session = psession->session; future = psession->future; } } if (future == NULL) { php5to7_zend_resource_le resource; session->session = cass_session_new(); if (keyspace) { future = cass_session_connect_keyspace(session->session, cluster->cluster, keyspace); } else { future = cass_session_connect(session->session, cluster->cluster); } if (session->persist) { psession = (cassandra_psession *) pecalloc(1, sizeof(cassandra_psession), 1); psession->session = session->session; psession->future = future; #if PHP_MAJOR_VERSION >= 7 ZVAL_NEW_PERSISTENT_RES(&resource, 0, psession, php_le_cassandra_session()); PHP5TO7_ZEND_HASH_UPDATE(&EG(persistent_list), hash_key, hash_key_len + 1, &resource, sizeof(php5to7_zend_resource_le)); CASSANDRA_G(persistent_sessions)++; #else resource.type = php_le_cassandra_session(); resource.ptr = psession; PHP5TO7_ZEND_HASH_UPDATE(&EG(persistent_list), hash_key, hash_key_len + 1, resource, sizeof(php5to7_zend_resource_le)); CASSANDRA_G(persistent_sessions)++; #endif } } if (php_cassandra_future_wait_timed(future, timeout TSRMLS_CC) == FAILURE) { if (session->persist) { efree(hash_key); } else { cass_future_free(future); } return; } if (php_cassandra_future_is_error(future TSRMLS_CC) == FAILURE) { if (session->persist) { if (PHP5TO7_ZEND_HASH_DEL(&EG(persistent_list), hash_key, hash_key_len + 1)) { session->session = NULL; } efree(hash_key); } else { cass_future_free(future); } return; } if (session->persist) efree(hash_key); }
PHP_METHOD(DefaultCluster, connectAsync) { char *hash_key; php5to7_size hash_key_len = 0; char *keyspace = NULL; php5to7_size keyspace_len; cassandra_cluster *cluster = NULL; cassandra_future_session *future = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &keyspace, &keyspace_len) == FAILURE) { return; } cluster = PHP_CASSANDRA_GET_CLUSTER(getThis()); object_init_ex(return_value, cassandra_future_session_ce); future = PHP_CASSANDRA_GET_FUTURE_SESSION(return_value); future->persist = cluster->persist; if (cluster->persist) { php5to7_zend_resource_le *le; hash_key_len = spprintf(&hash_key, 0, "%s:session:%s", cluster->hash_key, SAFE_STR(keyspace)); future->hash_key = hash_key; future->hash_key_len = hash_key_len; if (PHP5TO7_ZEND_HASH_FIND(&EG(persistent_list), hash_key, hash_key_len + 1, le)) { if (Z_TYPE_P(le) == php_le_cassandra_session()) { cassandra_psession *psession = (cassandra_psession *) Z_RES_P(le)->ptr; future->session = psession->session; future->future = psession->future; return; } } } future->session = cass_session_new(); if (keyspace) { future->future = cass_session_connect_keyspace(future->session, cluster->cluster, keyspace); } else { future->future = cass_session_connect(future->session, cluster->cluster); } if (cluster->persist) { php5to7_zend_resource_le resource; cassandra_psession *psession = (cassandra_psession *) pecalloc(1, sizeof(cassandra_psession), 1); psession->session = future->session; psession->future = future->future; #if PHP_MAJOR_VERSION >= 7 ZVAL_NEW_PERSISTENT_RES(&resource, 0, psession, php_le_cassandra_session()); PHP5TO7_ZEND_HASH_UPDATE(&EG(persistent_list), hash_key, hash_key_len + 1, &resource, sizeof(php5to7_zend_resource_le)); CASSANDRA_G(persistent_sessions)++; #else resource.type = php_le_cassandra_session(); resource.ptr = psession; PHP5TO7_ZEND_HASH_UPDATE(&EG(persistent_list), hash_key, hash_key_len + 1, resource, sizeof(php5to7_zend_resource_le)); CASSANDRA_G(persistent_sessions)++; #endif } }