int oilsAuthSessionRetrieve( osrfMethodContext* ctx ) {
OSRF_METHOD_VERIFY_CONTEXT(ctx);
bool returnFull = false;
const char* authToken = jsonObjectGetString( jsonObjectGetIndex(ctx->params, 0));
if(ctx->params->size > 1) {
// caller wants full cached object, with authtime, etc.
const char* rt = jsonObjectGetString(jsonObjectGetIndex(ctx->params, 1));
if(rt && strcmp(rt, "0") != 0)
returnFull = true;
}
jsonObject* cacheObj = NULL;
oilsEvent* evt = NULL;
if( authToken ){
// Reset the timeout to keep the session alive
evt = _oilsAuthResetTimeout(authToken, 0);
if( evt && strcmp(evt->event, OILS_EVENT_SUCCESS) ) {
osrfAppRespondComplete( ctx, oilsEventToJSON( evt )); // can't reset timeout
} else {
// Retrieve the cached session object
osrfLogDebug(OSRF_LOG_MARK, "Retrieving auth session: %s", authToken);
char* key = va_list_to_string("%s%s", OILS_AUTH_CACHE_PRFX, authToken );
cacheObj = osrfCacheGetObject( key );
if(cacheObj) {
// Return a copy of the cached user object
if(returnFull)
osrfAppRespondComplete( ctx, cacheObj);
else
osrfAppRespondComplete( ctx, jsonObjectGetKeyConst( cacheObj, "userobj"));
jsonObjectFree(cacheObj);
} else {
// Auth token is invalid or expired
oilsEvent* evt2 = oilsNewEvent(OSRF_LOG_MARK, OILS_EVENT_NO_SESSION);
osrfAppRespondComplete( ctx, oilsEventToJSON(evt2) ); /* should be event.. */
oilsEventFree(evt2);
}
free(key);
}
} else {
// No session
evt = oilsNewEvent(OSRF_LOG_MARK, OILS_EVENT_NO_SESSION);
osrfAppRespondComplete( ctx, oilsEventToJSON(evt) );
}
if(evt)
oilsEventFree(evt);
return 0;
}
/**
Verifies that the user has permission to login with the
given type. If the permission fails, an oilsEvent is returned
to the caller.
@return -1 if the permission check failed, 0 if the permission
is granted
*/
static int oilsAuthCheckLoginPerm(
osrfMethodContext* ctx, const jsonObject* userObj, const char* type ) {
if(!(userObj && type)) return -1;
oilsEvent* perm = NULL;
if(!strcasecmp(type, OILS_AUTH_OPAC)) {
char* permissions[] = { "OPAC_LOGIN" };
perm = oilsUtilsCheckPerms( oilsFMGetObjectId( userObj ), -1, permissions, 1 );
} else if(!strcasecmp(type, OILS_AUTH_STAFF)) {
char* permissions[] = { "STAFF_LOGIN" };
perm = oilsUtilsCheckPerms( oilsFMGetObjectId( userObj ), -1, permissions, 1 );
} else if(!strcasecmp(type, OILS_AUTH_TEMP)) {
char* permissions[] = { "STAFF_LOGIN" };
perm = oilsUtilsCheckPerms( oilsFMGetObjectId( userObj ), -1, permissions, 1 );
} else if(!strcasecmp(type, OILS_AUTH_PERSIST)) {
char* permissions[] = { "PERSISTENT_LOGIN" };
perm = oilsUtilsCheckPerms( oilsFMGetObjectId( userObj ), -1, permissions, 1 );
}
if(perm) {
osrfAppRespondComplete( ctx, oilsEventToJSON(perm) );
oilsEventFree(perm);
return -1;
}
return 0;
}
int oilsAuthResetTimeout( osrfMethodContext* ctx ) {
OSRF_METHOD_VERIFY_CONTEXT(ctx);
const char* authToken = jsonObjectGetString( jsonObjectGetIndex(ctx->params, 0));
oilsEvent* evt = _oilsAuthResetTimeout(authToken);
osrfAppRespondComplete( ctx, oilsEventToJSON(evt) );
oilsEventFree(evt);
return 0;
}
/**
@brief Implement the "complete" method.
@param ctx The method context.
@return -1 upon error; zero if successful, and if a STATUS message has been sent to the
client to indicate completion; a positive integer if successful but no such STATUS
message has been sent.
Method parameters:
- a hash with some combination of the following elements:
- "username"
- "barcode"
- "password" (hashed with the cached seed; not plaintext)
- "type"
- "org"
- "workstation"
The password is required. Either a username or a barcode must also be present.
Return to client: Intermediate authentication seed.
Validate the password, using the username if available, or the barcode if not. The
user must be active, and not barred from logging on. The barcode, if used for
authentication, must be active as well. The workstation, if specified, must be valid.
Upon deciding whether to allow the logon, return a corresponding event to the client.
*/
int oilsAuthComplete( osrfMethodContext* ctx ) {
OSRF_METHOD_VERIFY_CONTEXT(ctx);
const jsonObject* args = jsonObjectGetIndex(ctx->params, 0);
const char* uname = jsonObjectGetString(jsonObjectGetKeyConst(args, "username"));
const char* password = jsonObjectGetString(jsonObjectGetKeyConst(args, "password"));
const char* type = jsonObjectGetString(jsonObjectGetKeyConst(args, "type"));
int orgloc = (int) jsonObjectGetNumber(jsonObjectGetKeyConst(args, "org"));
const char* workstation = jsonObjectGetString(jsonObjectGetKeyConst(args, "workstation"));
const char* barcode = jsonObjectGetString(jsonObjectGetKeyConst(args, "barcode"));
const char* ws = (workstation) ? workstation : "";
if( !type )
type = OILS_AUTH_STAFF;
if( !( (uname || barcode) && password) ) {
return osrfAppRequestRespondException( ctx->session, ctx->request,
"username/barcode and password required for method: %s", ctx->method->name );
}
oilsEvent* response = NULL;
jsonObject* userObj = NULL;
int card_active = 1; // boolean; assume active until proven otherwise
// Fetch a row from the actor.usr table, by username if available,
// or by barcode if not.
if(uname) {
userObj = oilsUtilsFetchUserByUsername( uname );
if( userObj && JSON_NULL == userObj->type ) {
jsonObjectFree( userObj );
userObj = NULL; // username not found
}
}
else if(barcode) {
// Read from actor.card by barcode
osrfLogInfo( OSRF_LOG_MARK, "Fetching user by barcode %s", barcode );
jsonObject* params = jsonParseFmt("{\"barcode\":\"%s\"}", barcode);
jsonObject* card = oilsUtilsQuickReq(
"open-ils.cstore", "open-ils.cstore.direct.actor.card.search", params );
jsonObjectFree( params );
if( card && card->type != JSON_NULL ) {
// Determine whether the card is active
char* card_active_str = oilsFMGetString( card, "active" );
card_active = oilsUtilsIsDBTrue( card_active_str );
free( card_active_str );
// Look up the user who owns the card
char* userid = oilsFMGetString( card, "usr" );
jsonObjectFree( card );
params = jsonParseFmt( "[%s]", userid );
free( userid );
userObj = oilsUtilsQuickReq(
"open-ils.cstore", "open-ils.cstore.direct.actor.user.retrieve", params );
jsonObjectFree( params );
if( userObj && JSON_NULL == userObj->type ) {
// user not found (shouldn't happen, due to foreign key)
jsonObjectFree( userObj );
userObj = NULL;
}
}
}
if(!userObj) {
response = oilsNewEvent( OSRF_LOG_MARK, OILS_EVENT_AUTH_FAILED );
osrfLogInfo(OSRF_LOG_MARK, "failed login: username=%s, barcode=%s, workstation=%s",
uname, (barcode ? barcode : "(none)"), ws );
osrfAppRespondComplete( ctx, oilsEventToJSON(response) );
oilsEventFree(response);
return 0; // No such user
}
// Such a user exists. Now see if he or she has the right credentials.
int passOK = -1;
if(uname)
passOK = oilsAuthVerifyPassword( ctx, userObj, uname, password );
else if (barcode)
passOK = oilsAuthVerifyPassword( ctx, userObj, barcode, password );
if( passOK < 0 ) {
jsonObjectFree(userObj);
return passOK;
}
// See if the account is active
char* active = oilsFMGetString(userObj, "active");
if( !oilsUtilsIsDBTrue(active) ) {
if( passOK )
response = oilsNewEvent( OSRF_LOG_MARK, "PATRON_INACTIVE" );
else
response = oilsNewEvent( OSRF_LOG_MARK, OILS_EVENT_AUTH_FAILED );
osrfAppRespondComplete( ctx, oilsEventToJSON(response) );
oilsEventFree(response);
jsonObjectFree(userObj);
free(active);
return 0;
}
free(active);
osrfLogInfo( OSRF_LOG_MARK, "Fetching card by barcode %s", barcode );
if( !card_active ) {
osrfLogInfo( OSRF_LOG_MARK, "barcode %s is not active, returning event", barcode );
response = oilsNewEvent( OSRF_LOG_MARK, "PATRON_CARD_INACTIVE" );
osrfAppRespondComplete( ctx, oilsEventToJSON( response ) );
oilsEventFree( response );
jsonObjectFree( userObj );
return 0;
}
// See if the user is even allowed to log in
if( oilsAuthCheckLoginPerm( ctx, userObj, type ) == -1 ) {
jsonObjectFree(userObj);
return 0;
}
// If a workstation is defined, add the workstation info
if( workstation != NULL ) {
osrfLogDebug(OSRF_LOG_MARK, "Workstation is %s", workstation);
response = oilsAuthVerifyWorkstation( ctx, userObj, workstation );
if(response) {
jsonObjectFree(userObj);
osrfAppRespondComplete( ctx, oilsEventToJSON(response) );
oilsEventFree(response);
return 0;
}
} else {
// Otherwise, use the home org as the workstation org on the user
char* orgid = oilsFMGetString(userObj, "home_ou");
oilsFMSetString(userObj, "ws_ou", orgid);
free(orgid);
}
char* freeable_uname = NULL;
if(!uname) {
uname = freeable_uname = oilsFMGetString( userObj, "usrname" );
}
if( passOK ) {
response = oilsAuthHandleLoginOK( userObj, uname, type, orgloc, workstation );
} else {
response = oilsNewEvent( OSRF_LOG_MARK, OILS_EVENT_AUTH_FAILED );
osrfLogInfo(OSRF_LOG_MARK, "failed login: username=%s, barcode=%s, workstation=%s",
uname, (barcode ? barcode : "(none)"), ws );
}
jsonObjectFree(userObj);
osrfAppRespondComplete( ctx, oilsEventToJSON(response) );
oilsEventFree(response);
if(freeable_uname)
free(freeable_uname);
return 0;
}
int oilsAuthLogin(osrfMethodContext* ctx) {
OSRF_METHOD_VERIFY_CONTEXT(ctx);
const jsonObject* args = jsonObjectGetIndex(ctx->params, 0);
const char* username = jsonObjectGetString(jsonObjectGetKeyConst(args, "username"));
const char* identifier = jsonObjectGetString(jsonObjectGetKeyConst(args, "identifier"));
const char* password = jsonObjectGetString(jsonObjectGetKeyConst(args, "password"));
const char* type = jsonObjectGetString(jsonObjectGetKeyConst(args, "type"));
int orgloc = (int) jsonObjectGetNumber(jsonObjectGetKeyConst(args, "org"));
const char* workstation = jsonObjectGetString(jsonObjectGetKeyConst(args, "workstation"));
const char* barcode = jsonObjectGetString(jsonObjectGetKeyConst(args, "barcode"));
const char* ewho = jsonObjectGetString(jsonObjectGetKeyConst(args, "agent"));
const char* ws = (workstation) ? workstation : "";
if (!type) type = OILS_AUTH_STAFF;
jsonObject* userObj = NULL; // free me
oilsEvent* response = NULL; // free me
/* Use __FILE__, harmless_line_number for creating
* OILS_EVENT_AUTH_FAILED events (instead of OSRF_LOG_MARK) to avoid
* giving away information about why an authentication attempt failed.
*/
int harmless_line_number = __LINE__;
// translate a generic identifier into a username or barcode if necessary.
if (identifier && !username && !barcode) {
if (oilsAuthIdentIsBarcode(identifier, orgloc)) {
barcode = identifier;
} else {
username = identifier;
}
}
if (username) {
barcode = NULL; // avoid superfluous identifiers
userObj = oilsUtilsFetchUserByUsername(ctx, username);
} else if (barcode) {
userObj = oilsUtilsFetchUserByBarcode(ctx, barcode);
} else {
// not enough params
return osrfAppRequestRespondException(ctx->session, ctx->request,
"username/barcode and password required for method: %s",
ctx->method->name);
}
if (!userObj) { // user not found.
response = oilsNewEvent(
__FILE__, harmless_line_number, OILS_EVENT_AUTH_FAILED);
osrfAppRespondComplete(ctx, oilsEventToJSON(response));
oilsEventFree(response); // frees event JSON
return 0;
}
long user_id = oilsFMGetObjectId(userObj);
// username is freed when userObj is freed.
// From here we can use the username as the generic identifier
// since it's guaranteed to have a value.
if (!username) username = oilsFMGetStringConst(userObj, "usrname");
// See if the user is allowed to login.
jsonObject* params = jsonNewObject(NULL);
jsonObjectSetKey(params, "user_id", jsonNewNumberObject(user_id));
jsonObjectSetKey(params,"org_unit", jsonNewNumberObject(orgloc));
jsonObjectSetKey(params, "login_type", jsonNewObject(type));
if (barcode) jsonObjectSetKey(params, "barcode", jsonNewObject(barcode));
jsonObject* authEvt = oilsUtilsQuickReqCtx( // freed after password test
ctx,
"open-ils.auth_internal",
"open-ils.auth_internal.user.validate", params);
jsonObjectFree(params);
if (!authEvt) { // unknown error
jsonObjectFree(userObj);
return -1;
}
const char* authEvtCode =
jsonObjectGetString(jsonObjectGetKey(authEvt, "textcode"));
if (!strcmp(authEvtCode, OILS_EVENT_AUTH_FAILED)) {
// Received the generic login failure event.
osrfLogInfo(OSRF_LOG_MARK,
"failed login: username=%s, barcode=%s, workstation=%s",
username, (barcode ? barcode : "(none)"), ws);
response = oilsNewEvent(
__FILE__, harmless_line_number, OILS_EVENT_AUTH_FAILED);
}
if (!response && // user exists and is not barred, etc.
!oilsAuthLoginVerifyPassword(ctx, user_id, username, password)) {
// User provided the wrong password or is blocked from too
// many previous login failures.
response = oilsNewEvent(
__FILE__, harmless_line_number, OILS_EVENT_AUTH_FAILED);
osrfLogInfo(OSRF_LOG_MARK,
"failed login: username=%s, barcode=%s, workstation=%s",
username, (barcode ? barcode : "(none)"), ws );
}
// Below here, we know the password check succeeded if no response
// object is present.
if (!response && (
!strcmp(authEvtCode, "PATRON_INACTIVE") ||
!strcmp(authEvtCode, "PATRON_CARD_INACTIVE"))) {
// Patron and/or card is inactive but the correct password
// was provided. Alert the caller to the inactive-ness.
response = oilsNewEvent2(
OSRF_LOG_MARK, authEvtCode,
jsonObjectGetKey(authEvt, "payload") // cloned within Event
);
}
if (!response && strcmp(authEvtCode, OILS_EVENT_SUCCESS)) {
// Validate API returned an unexpected non-success event.
// To be safe, treat this as a generic login failure.
response = oilsNewEvent(
__FILE__, harmless_line_number, OILS_EVENT_AUTH_FAILED);
}
if (!response) {
// password OK and no other events have prevented login completion.
char* ewhat = "login";
if (0 == strcmp(ctx->method->name, "open-ils.auth.authenticate.verify")) {
response = oilsNewEvent( OSRF_LOG_MARK, OILS_EVENT_SUCCESS );
ewhat = "verify";
} else {
response = oilsAuthHandleLoginOK(
ctx, userObj, username, type, orgloc, workstation);
}
oilsUtilsTrackUserActivity(
ctx,
oilsFMGetObjectId(userObj),
ewho, ewhat,
osrfAppSessionGetIngress()
);
}
// reply
osrfAppRespondComplete(ctx, oilsEventToJSON(response));
// clean up
oilsEventFree(response);
jsonObjectFree(userObj);
jsonObjectFree(authEvt);
return 0;
}
/**
@brief Implement the "complete" method.
@param ctx The method context.
@return -1 upon error; zero if successful, and if a STATUS message has been sent to the
client to indicate completion; a positive integer if successful but no such STATUS
message has been sent.
Method parameters:
- a hash with some combination of the following elements:
- "username"
- "barcode"
- "password" (hashed with the cached seed; not plaintext)
- "type"
- "org"
- "workstation"
- "agent" (what software/interface/3rd-party is making the request)
- "nonce" optional login seed to differentiate logins using the same username.
The password is required. Either a username or a barcode must also be present.
Return to client: Intermediate authentication seed.
Validate the password, using the username if available, or the barcode if not. The
user must be active, and not barred from logging on. The barcode, if used for
authentication, must be active as well. The workstation, if specified, must be valid.
Upon deciding whether to allow the logon, return a corresponding event to the client.
*/
int oilsAuthComplete( osrfMethodContext* ctx ) {
OSRF_METHOD_VERIFY_CONTEXT(ctx);
const jsonObject* args = jsonObjectGetIndex(ctx->params, 0);
const char* uname = jsonObjectGetString(jsonObjectGetKeyConst(args, "username"));
const char* identifier = jsonObjectGetString(jsonObjectGetKeyConst(args, "identifier"));
const char* password = jsonObjectGetString(jsonObjectGetKeyConst(args, "password"));
const char* type = jsonObjectGetString(jsonObjectGetKeyConst(args, "type"));
int orgloc = (int) jsonObjectGetNumber(jsonObjectGetKeyConst(args, "org"));
const char* workstation = jsonObjectGetString(jsonObjectGetKeyConst(args, "workstation"));
const char* barcode = jsonObjectGetString(jsonObjectGetKeyConst(args, "barcode"));
const char* ewho = jsonObjectGetString(jsonObjectGetKeyConst(args, "agent"));
const char* nonce = jsonObjectGetString(jsonObjectGetKeyConst(args, "nonce"));
const char* ws = (workstation) ? workstation : "";
if (!nonce) nonce = "";
// we no longer care how the identifier reaches us,
// as long as we have one.
if (!identifier) {
if (uname) {
identifier = uname;
} else if (barcode) {
identifier = barcode;
}
}
if (!identifier) {
return osrfAppRequestRespondException(ctx->session, ctx->request,
"username/barcode and password required for method: %s",
ctx->method->name);
}
osrfLogInfo(OSRF_LOG_MARK,
"Patron completing authentication with identifer %s", identifier);
/* Use __FILE__, harmless_line_number for creating
* OILS_EVENT_AUTH_FAILED events (instead of OSRF_LOG_MARK) to avoid
* giving away information about why an authentication attempt failed.
*/
int harmless_line_number = __LINE__;
if( !type )
type = OILS_AUTH_STAFF;
oilsEvent* response = NULL; // free
jsonObject* userObj = NULL; // free
char* cache_key = va_list_to_string(
"%s%s%s", OILS_AUTH_CACHE_PRFX, identifier, nonce);
jsonObject* cacheObj = osrfCacheGetObject(cache_key); // free
if (!cacheObj) {
return osrfAppRequestRespondException(ctx->session,
ctx->request, "No authentication seed found. "
"open-ils.auth.authenticate.init must be called first "
" (check that memcached is running and can be connected to) "
);
}
int user_id = jsonObjectGetNumber(
jsonObjectGetKeyConst(cacheObj, "user_id"));
if (user_id == -1) {
// User was not found during init. Clean up and exit early.
response = oilsNewEvent(
__FILE__, harmless_line_number, OILS_EVENT_AUTH_FAILED);
osrfAppRespondComplete(ctx, oilsEventToJSON(response));
oilsEventFree(response); // frees event JSON
osrfCacheRemove(cache_key);
jsonObjectFree(cacheObj);
return 0;
}
jsonObject* param = jsonNewNumberObject(user_id); // free
userObj = oilsUtilsCStoreReqCtx(
ctx, "open-ils.cstore.direct.actor.user.retrieve", param);
jsonObjectFree(param);
char* freeable_uname = NULL;
if (!uname) {
uname = freeable_uname = oilsFMGetString(userObj, "usrname");
}
// See if the user is allowed to login.
jsonObject* params = jsonNewObject(NULL);
jsonObjectSetKey(params, "user_id",
jsonNewNumberObject(oilsFMGetObjectId(userObj)));
jsonObjectSetKey(params,"org_unit", jsonNewNumberObject(orgloc));
jsonObjectSetKey(params, "login_type", jsonNewObject(type));
if (barcode) jsonObjectSetKey(params, "barcode", jsonNewObject(barcode));
jsonObject* authEvt = oilsUtilsQuickReqCtx( // freed after password test
ctx,
"open-ils.auth_internal",
"open-ils.auth_internal.user.validate", params);
jsonObjectFree(params);
if (!authEvt) {
// Something went seriously wrong. Get outta here before
// we start segfaulting.
jsonObjectFree(userObj);
if(freeable_uname) free(freeable_uname);
return -1;
}
const char* authEvtCode =
jsonObjectGetString(jsonObjectGetKey(authEvt, "textcode"));
if (!strcmp(authEvtCode, OILS_EVENT_AUTH_FAILED)) {
// Received the generic login failure event.
osrfLogInfo(OSRF_LOG_MARK,
"failed login: username=%s, barcode=%s, workstation=%s",
uname, (barcode ? barcode : "(none)"), ws);
response = oilsNewEvent(
__FILE__, harmless_line_number, OILS_EVENT_AUTH_FAILED);
}
int passOK = 0;
if (!response) {
// User exists and is not barred, etc. Test the password.
passOK = oilsAuthVerifyPassword(
ctx, user_id, identifier, password, nonce);
if (!passOK) {
// Password check failed. Return generic login failure.
response = oilsNewEvent(
__FILE__, harmless_line_number, OILS_EVENT_AUTH_FAILED);
osrfLogInfo(OSRF_LOG_MARK,
"failed login: username=%s, barcode=%s, workstation=%s",
uname, (barcode ? barcode : "(none)"), ws );
}
}
// Below here, we know the password check succeeded if no response
// object is present.
if (!response && (
!strcmp(authEvtCode, "PATRON_INACTIVE") ||
!strcmp(authEvtCode, "PATRON_CARD_INACTIVE"))) {
// Patron and/or card is inactive but the correct password
// was provided. Alert the caller to the inactive-ness.
response = oilsNewEvent2(
OSRF_LOG_MARK, authEvtCode,
jsonObjectGetKey(authEvt, "payload") // cloned within Event
);
}
if (!response && strcmp(authEvtCode, OILS_EVENT_SUCCESS)) {
// Validate API returned an unexpected non-success event.
// To be safe, treat this as a generic login failure.
response = oilsNewEvent(
__FILE__, harmless_line_number, OILS_EVENT_AUTH_FAILED);
}
if (!response) {
// password OK and no other events have prevented login completion.
char* ewhat = "login";
if (0 == strcmp(ctx->method->name, "open-ils.auth.authenticate.verify")) {
response = oilsNewEvent( OSRF_LOG_MARK, OILS_EVENT_SUCCESS );
ewhat = "verify";
} else {
response = oilsAuthHandleLoginOK(
ctx, userObj, uname, type, orgloc, workstation);
}
oilsUtilsTrackUserActivity(
ctx,
oilsFMGetObjectId(userObj),
ewho, ewhat,
osrfAppSessionGetIngress()
);
}
// reply
osrfAppRespondComplete(ctx, oilsEventToJSON(response));
// clean up
oilsEventFree(response);
jsonObjectFree(userObj);
jsonObjectFree(authEvt);
jsonObjectFree(cacheObj);
if(freeable_uname)
free(freeable_uname);
return 0;
}
int oilsAuthInternalValidate(osrfMethodContext* ctx) {
OSRF_METHOD_VERIFY_CONTEXT(ctx);
const jsonObject* args = jsonObjectGetIndex(ctx->params, 0);
const char* user_id = jsonObjectGetString(jsonObjectGetKeyConst(args, "user_id"));
const char* barcode = jsonObjectGetString(jsonObjectGetKeyConst(args, "barcode"));
const char* login_type = jsonObjectGetString(jsonObjectGetKeyConst(args, "login_type"));
int org_unit = jsonObjectGetNumber(jsonObjectGetKeyConst(args, "org_unit"));
if ( !(user_id && login_type) ) {
return osrfAppRequestRespondException( ctx->session, ctx->request,
"Missing parameters for method: %s", ctx->method->name );
}
oilsEvent* response = NULL;
jsonObject *userObj = NULL, *params = NULL;
char* tmp_str = NULL;
int user_exists = 0, user_active = 0,
user_barred = 0, user_deleted = 0;
// Confirm user exists, active=true, barred=false, deleted=false
params = jsonNewNumberStringObject(user_id);
userObj = oilsUtilsCStoreReqCtx(
ctx, "open-ils.cstore.direct.actor.user.retrieve", params);
jsonObjectFree(params);
if (userObj && userObj->type != JSON_NULL) {
user_exists = 1;
tmp_str = oilsFMGetString(userObj, "active");
user_active = oilsUtilsIsDBTrue(tmp_str);
free(tmp_str);
tmp_str = oilsFMGetString(userObj, "barred");
user_barred = oilsUtilsIsDBTrue(tmp_str);
free(tmp_str);
tmp_str = oilsFMGetString(userObj, "deleted");
user_deleted = oilsUtilsIsDBTrue(tmp_str);
free(tmp_str);
}
if (!user_exists || user_barred || user_deleted) {
response = oilsNewEvent(OILS_LOG_MARK_SAFE, OILS_EVENT_AUTH_FAILED);
}
if (!response && !user_active) {
// In some cases, it's useful for the caller to know if the
// patron was unable to login becuase the account is inactive.
// Return a specific event for this.
response = oilsNewEvent(OILS_LOG_MARK_SAFE, "PATRON_INACTIVE");
}
if (!response && barcode) {
// Caller provided a barcode. Ensure it exists and is active.
int card_ok = 0;
params = jsonParseFmt("{\"barcode\":\"%s\"}", barcode);
jsonObject* card = oilsUtilsCStoreReqCtx(
ctx, "open-ils.cstore.direct.actor.card.search", params);
jsonObjectFree(params);
if (card && card->type != JSON_NULL) {
tmp_str = oilsFMGetString(card, "active");
card_ok = oilsUtilsIsDBTrue(tmp_str);
free(tmp_str);
}
jsonObjectFree(card); // card=NULL OK here.
if (!card_ok) {
response = oilsNewEvent(
OILS_LOG_MARK_SAFE, "PATRON_CARD_INACTIVE");
}
}
// XXX: login permission checks are always global (see
// oilsAuthCheckLoginPerm()). No need to extract the
// workstation org unit here.
if (!response) { // Still OK
// Confirm user has permission to login w/ the requested type.
response = oilsAuthCheckLoginPerm(
ctx, atoi(user_id), org_unit, login_type);
}
if (!response) {
// No tests failed. Return SUCCESS.
response = oilsNewEvent(OSRF_LOG_MARK, OILS_EVENT_SUCCESS);
}
jsonObjectFree(userObj); // userObj=NULL OK here.
osrfAppRespondComplete(ctx, oilsEventToJSON(response));
oilsEventFree(response);
return 0;
}
/**
@brief Implement the session create method
@param ctx The method context.
@return -1 upon error; zero if successful, and if a STATUS message has
been sent to the client to indicate completion; a positive integer if
successful but no such STATUS message has been sent.
Method parameters:
- a hash with some combination of the following elements:
- "user_id" -- actor.usr (au) ID for the user to cache.
- "org_unit" -- actor.org_unit (aou) ID representing the physical
location / context used for timeout, etc. settings.
- "login_type" -- login type (opac, staff, temp, persist)
- "workstation" -- workstation name
*/
int oilsAuthInternalCreateSession(osrfMethodContext* ctx) {
OSRF_METHOD_VERIFY_CONTEXT(ctx);
const jsonObject* args = jsonObjectGetIndex(ctx->params, 0);
const char* user_id = jsonObjectGetString(jsonObjectGetKeyConst(args, "user_id"));
const char* login_type = jsonObjectGetString(jsonObjectGetKeyConst(args, "login_type"));
const char* workstation = jsonObjectGetString(jsonObjectGetKeyConst(args, "workstation"));
int org_unit = jsonObjectGetNumber(jsonObjectGetKeyConst(args, "org_unit"));
if ( !(user_id && login_type) ) {
return osrfAppRequestRespondException( ctx->session, ctx->request,
"Missing parameters for method: %s", ctx->method->name );
}
oilsEvent* response = NULL;
// fetch the user object
jsonObject* idParam = jsonNewNumberStringObject(user_id);
jsonObject* userObj = oilsUtilsCStoreReqCtx(
ctx, "open-ils.cstore.direct.actor.user.retrieve", idParam);
jsonObjectFree(idParam);
if (!userObj) {
return osrfAppRequestRespondException(ctx->session,
ctx->request, "No user found with ID %s", user_id);
}
// If a workstation is defined, add the workstation info
if (workstation) {
response = oilsAuthVerifyWorkstation(ctx, userObj, workstation);
if (response) { // invalid workstation.
jsonObjectFree(userObj);
osrfAppRespondComplete(ctx, oilsEventToJSON(response));
oilsEventFree(response);
return 0;
} else { // workstation OK.
// The worksation org unit supersedes any org unit value
// provided via the API. oilsAuthVerifyWorkstation() sets the
// ws_ou value to the WS owning lib. A value is guaranteed.
org_unit = atoi(oilsFMGetStringConst(userObj, "ws_ou"));
}
} else { // no workstation
// For backwards compatibility, when no workstation is provided, use
// the users's home org as its workstation org unit, regardless of
// any API-level org unit value provided.
const char* orgid = oilsFMGetStringConst(userObj, "home_ou");
oilsFMSetString(userObj, "ws_ou", orgid);
// The context org unit defaults to the user's home library when
// no workstation is used and no API-level value is provided.
if (org_unit < 1) org_unit = atoi(orgid);
}
// determine the auth/cache timeout
long timeout = oilsAuthGetTimeout(userObj, login_type, org_unit);
char* string = va_list_to_string("%d.%ld.%ld",
(long) getpid(), time(NULL), oilsFMGetObjectId(userObj));
char* authToken = md5sum(string);
char* authKey = va_list_to_string(
"%s%s", OILS_AUTH_CACHE_PRFX, authToken);
oilsFMSetString(userObj, "passwd", "");
jsonObject* cacheObj = jsonParseFmt("{\"authtime\": %ld}", timeout);
jsonObjectSetKey(cacheObj, "userobj", jsonObjectClone(userObj));
if( !strcmp(login_type, OILS_AUTH_PERSIST)) {
// Add entries for endtime and reset_interval, so that we can gracefully
// extend the session a bit if the user is active toward the end of the
// timeout originally specified.
time_t endtime = time( NULL ) + timeout;
jsonObjectSetKey(cacheObj, "endtime",
jsonNewNumberObject( (double) endtime ));
// Reset interval is hard-coded for now, but if we ever want to make it
// configurable, this is the place to do it:
jsonObjectSetKey(cacheObj, "reset_interval",
jsonNewNumberObject( (double) DEFAULT_RESET_INTERVAL));
}
osrfCachePutObject(authKey, cacheObj, (time_t) timeout);
jsonObjectFree(cacheObj);
jsonObject* payload = jsonParseFmt(
"{\"authtoken\": \"%s\", \"authtime\": %ld}", authToken, timeout);
response = oilsNewEvent2(OSRF_LOG_MARK, OILS_EVENT_SUCCESS, payload);
free(string); free(authToken); free(authKey);
jsonObjectFree(payload);
jsonObjectFree(userObj);
osrfAppRespondComplete(ctx, oilsEventToJSON(response));
oilsEventFree(response);
return 0;
}