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
}
}
