GSTATUS
DDSDeleteAssUserDB (
u_i4 user_id,
u_i4 db_id)
{
GSTATUS err = GSTAT_OK;
err = DDFSemOpen(&dds_semaphore, TRUE);
if (err == GSTAT_OK)
{
err = DDGDelete(
&dds_session,
DDS_OBJ_ASS_USER_DB,
"%d%d",
&user_id,
&db_id);
if (err == GSTAT_OK)
err = DDSMemDeleteAssUserDB(user_id, db_id);
if (err == GSTAT_OK)
err = DDGCommit(&dds_session);
else
CLEAR_STATUS(DDGRollback(&dds_session));
CLEAR_STATUS(DDFSemClose(&dds_semaphore));
}
return(err);
}
/*
** Name: WSMReleaseUsrSession() - Release user session
**
** Description:
**
** Inputs:
** USR_PSESSION *usr_session
**
** Outputs:
**
** Returns:
** GSTATUS : GSTAT_OK
**
** Exceptions:
** None
**
** Side Effects:
** None
**
** History:
** 03-Jul-98 (fanra01)
** Enable removal of user session instance for ima.
*/
GSTATUS
WSMReleaseUsrSession(
USR_PSESSION usr_session)
{
GSTATUS err = GSTAT_OK;
if (usr_session == NULL)
return(GSTAT_OK);
err = DDFSemOpen(&usrSessSemaphore, TRUE);
if (err == GSTAT_OK)
{
if (usr_session->requested_counter > 0)
usr_session->requested_counter--;
if (usr_session->timeout_end == 0)
{
if (usr_session->requested_counter == 0)
CLEAR_STATUS(WSMRemoveUsrSession(usr_session));
}
else
err = WSMSetTimeout(usr_session);
CLEAR_STATUS(DDFSemClose(&usrSessSemaphore));
}
return(err);
}
GSTATUS
DDSCloseDB (PTR *cursor)
{
GSTATUS err = GSTAT_OK;
err = DDGClose(&dds_session);
if (err == GSTAT_OK)
err = DDGCommit(&dds_session);
else
CLEAR_STATUS(DDGRollback(&dds_session));
CLEAR_STATUS(DDFSemClose(&dds_semaphore));
return(err);
}
/*
** Name: FWrite_Fvalue
**
** Decription:
** The input buffer should be written to file.
**
** Inputs:
** sess ice session structure
** line pointer to the current line
** linelen length of the line
**
** Outputs:
** pos number of characters handled.
**
** Return:
** GSTAT_OK success
** other failure
**
** History:
** 23-Oct-98 (fanra01)
** Created.
*/
static GSTATUS
FWrite_Fvalue (WTS_SESSION* sess, char* line, i4 linelen, i4 * pos)
{
GSTATUS err = GSTAT_OK;
PWTS_UPLOAD load= sess->load;
i4 count =0;
if ((err = WCSWrite(linelen, line, &count, sess->list->file)) == GSTAT_OK)
{
load->state = US_FWRITE;
}
else
{
UPLOADED_FILE* upload = sess->list;
if (upload != NULL)
{
sess->list = upload->next;
CLEAR_STATUS(WCSClose(upload->file));
MEfree ((PTR)upload);
}
}
*pos += count;
return (err);
}
/*
** Name: WSMCleanUserTimeout() - Clean the timeout system
**
** Description:
**
** Inputs:
**
** Outputs:
**
** Returns:
** GSTATUS : GSTAT_OK
**
** Exceptions:
** None
**
** Side Effects:
** None
**
** History:
*/
GSTATUS
WSMCleanUserTimeout()
{
GSTATUS err = GSTAT_OK;
USR_PSESSION tmp = oldest;
USR_PSESSION next;
i4 limit = TMsecs();
err = DDFSemOpen(&usrSessSemaphore, TRUE);
if (err == GSTAT_OK)
{
while (tmp != NULL &&
tmp->timeout_end < limit)
{
next = tmp->timeout_next;
CLEAR_STATUS(WSMRemoveUsrSession(tmp));
tmp = next;
}
CLEAR_STATUS(DDFSemClose(&usrSessSemaphore));
}
return(err);
}
GSTATUS
DDSCreateDB (
char *name,
char *dbname,
u_i4 dbuser_id,
i4 flags,
char *comment,
u_i4 *id)
{
GSTATUS err = GSTAT_OK;
err = DDFSemOpen(&dds_semaphore, TRUE);
if (err == GSTAT_OK)
{
err = DDSPerformDBId(id);
if (err == GSTAT_OK)
{
err = DDGInsert(
&dds_session,
DDS_OBJ_DB,
"%d%s%s%d%d%s",
id,
name,
dbname,
&dbuser_id,
&flags,
comment);
if (err == GSTAT_OK)
err = DDSMemCreateDB( *id, name, dbname, dbuser_id, flags );
if (err == GSTAT_OK)
err = DDGCommit(&dds_session);
else
CLEAR_STATUS(DDGRollback(&dds_session));
}
CLEAR_STATUS(DDFSemClose(&dds_semaphore));
}
return(err);
}
GSTATUS
DDSDeleteDB (
u_i4 id)
{
GSTATUS err = GSTAT_OK;
err = DDFSemOpen(&dds_semaphore, TRUE);
if (err == GSTAT_OK)
{
err = DDGDelete(&dds_session, DDS_OBJ_DB, "%d", &id);
if (err == GSTAT_OK)
err = DDSMemDeleteDB(id);
if (err == GSTAT_OK)
err = DDGCommit(&dds_session);
else
CLEAR_STATUS(DDGRollback(&dds_session));
CLEAR_STATUS(DDFSemClose(&dds_semaphore));
}
return(err);
}
GSTATUS
DDSRetrieveDB (
u_i4 id,
char **name,
char **dbname,
u_i4 **dbuser_id,
i4 **flags,
char **comment)
{
GSTATUS err = GSTAT_OK;
err = DDFSemOpen(&dds_semaphore, TRUE);
if (err == GSTAT_OK)
{
err = DDGKeySelect(
&dds_session,
DDS_OBJ_DB,
"%d%s%s%d%d%s",
&id,
name,
dbname,
dbuser_id,
flags,
comment);
if (err == GSTAT_OK)
err = DDGClose(&dds_session);
if (err == GSTAT_OK)
err = DDGCommit(&dds_session);
else
CLEAR_STATUS(DDGRollback(&dds_session));
CLEAR_STATUS(DDFSemClose(&dds_semaphore));
}
return(err);
}
/*
** Name: WSMRemoveUsrSession() - remove a session from the hashtable and the timeout list.
**
** Description:
**
** Inputs:
** USR_PSESSION* : user session
**
** Outputs:
**
** Returns:
** GSTATUS : GSTAT_OK
**
** Exceptions:
** None
**
** Side Effects:
** None
**
** History:
** 03-Jun-1999 (fanra01)
** Add removal of user session variable semaphore.
*/
GSTATUS
WSMRemoveUsrSession (
USR_PSESSION session)
{
GSTATUS err = GSTAT_OK;
USR_PSESSION tmp;
CLEAR_STATUS(WPSCleanFilesTimeout (session->name));
CLEAR_STATUS(DDFdelhash(
usr_sessions,
session->name,
STlength(session->name),
(PTR*) &tmp));
CLEAR_STATUS(WSMRemoveTimeout(session));
if (session->requested_counter <= 0)
{
while (session->transactions != NULL)
CLEAR_STATUS( WSMRollback(session->transactions, FALSE) );
if (session->name != NULL)
usr_sess_detach(session->name);
if (session->userid != SYSTEM_ID)
CLEAR_STATUS(DDSReleaseUser(session->userid));
err = DDFSemOpen(&session->usrvarsem, TRUE);
if (err == GSTAT_OK)
{
CLEAR_STATUS(WSFCleanVariable(session->vars));
CLEAR_STATUS(DDFrmhash(&session->vars));
CLEAR_STATUS(DDFSemClose(&session->usrvarsem));
}
CLEAR_STATUS(DDFSemDestroy(&session->usrvarsem));
MEfreetag(session->mem_tag);
MEfree((PTR)session);
}
return(err);
}
GSTATUS
DDSGetDBName(
u_i4 id,
char** name)
{
GSTATUS err = GSTAT_OK;
err = DDFSemOpen(&dds_semaphore, FALSE);
if (err == GSTAT_OK)
{
err = DDSMemGetDBName(id, name);
CLEAR_STATUS(DDFSemClose(&dds_semaphore));
}
return(err);
}
GSTATUS
DDSUpdateDB (
u_i4 id,
char *name,
char *dbname,
u_i4 dbuser_id,
i4 flags,
char *comment)
{
GSTATUS err = GSTAT_OK;
err = DDFSemOpen(&dds_semaphore, TRUE);
if (err == GSTAT_OK)
{
err = DDGUpdate(
&dds_session,
DDS_OBJ_DB,
"%s%s%d%d%s%d",
name,
dbname,
&dbuser_id,
&flags,
comment,
&id);
if (err == GSTAT_OK)
err = DDSMemUpdateDB(id, name, dbname, flags, dbuser_id);
if (err == GSTAT_OK)
err = DDGCommit(&dds_session);
else
CLEAR_STATUS(DDGRollback(&dds_session));
CLEAR_STATUS(DDFSemClose(&dds_semaphore));
}
return(err);
}
/*
** Name: FWrite_EBound
**
** Decription:
** A terminating boundary is recevied during upload of a file. Indicating
** the file has completed and should now be closed.
**
** Inputs:
** sess ice session structure
** line pointer to the current line
** linelen length of the line
**
** Outputs:
** pos number of characters handled.
**
** Return:
** GSTAT_OK success
** other failure
**
** History:
** 23-Oct-98 (fanra01)
** Created.
*/
static GSTATUS
FWrite_EBound (WTS_SESSION* sess, char* line, i4 linelen, i4 * pos)
{
GSTATUS err = GSTAT_OK;
PWTS_UPLOAD load= sess->load;
UPLOADED_FILE* upload = sess->list;
if (upload != NULL)
{
sess->list = upload->next;
CLEAR_STATUS(WCSClose(upload->file));
MEfree ((PTR)upload);
}
load->state = US_END;
return (err);
}
/*
** Name: WSMRequestUsrSession() - Retrieve a user session from the cookie
**
** Description:
**
** Inputs:
** char* : cookie
**
** Outputs:
** USR_PSESSION* : user session (NULL if doesn't exist)
**
** Returns:
** GSTATUS : GSTAT_OK
**
** Exceptions:
** None
**
** Side Effects:
** None
**
** History:
** 04-Oct-2001 (fanra01)
** Add a test for an invalid session or a session that is no longer
** in the hash table and return an error.
*/
GSTATUS
WSMRequestUsrSession (
char *cookie,
USR_PSESSION *session)
{
GSTATUS err = GSTAT_OK;
u_i4 i = 0;
USR_PSESSION tmp = NULL;
if (cookie != NULL && cookie[0] != EOS)
{
err = DDFSemOpen(&usrSessSemaphore, TRUE);
if (err == GSTAT_OK)
{
err = DDFgethash(
usr_sessions,
cookie,
STlength(cookie),
(PTR*) &tmp);
/*
** If the object is not in the hash table, raise and error.
*/
if (tmp == NULL)
{
err = DDFStatusAlloc( E_WS0011_WSS_NO_OPEN_SESSION );
}
if (tmp != NULL &&
tmp->timeout_end < TMsecs())
tmp = NULL;
if (tmp != NULL)
tmp->requested_counter++;
CLEAR_STATUS(DDFSemClose(&usrSessSemaphore));
}
}
*session = tmp;
return(err);
}
/*
** Name: WTSCloseUpLoad() -
**
** Description:
**
** Inputs:
**
** Outputs:
**
** Returns:
** GSTATUS : GSTAT_OK
**
** Exceptions:
** None
**
** Side Effects:
** None
**
** History:
*/
GSTATUS
WTSCloseUpLoad(
WTS_SESSION *session)
{
GSTATUS err = GSTAT_OK;
PWTS_UPLOAD next = session->load;
PWTS_UPLOAD load;
UPLOADED_FILE* upload;
session->load = NULL;
while (next != NULL)
{
load = next;
if (load->state != US_END)
{
upload = session->list;
if (upload != NULL)
{
session->list = upload->next;
CLEAR_STATUS(WCSClose(upload->file));
MEfree ((PTR)upload);
}
/*
** Trace untimely end
*/
}
if (load->buf ) MEfree (load->buf );
if (load->start ) MEfree (load->start );
if (load->end ) MEfree (load->end );
if (load->varname ) MEfree (load->varname );
if (load->icefname) MEfree (load->icefname);
if (load->filename) MEfree (load->filename);
if (load->type ) MEfree (load->type );
if (load->encode ) MEfree (load->encode );
next = load->next;
MEfree ((PTR)load);
}
return(err);
}
/*
** Name: WSMReleaseActSession() - Clean an active session
**
** Description:
**
** Inputs:
** ACT_PSESSION* : active session
**
** Outputs:
** ACT_PSESSION* : active session
**
** Returns:
** GSTATUS : GSTAT_OK
**
** Exceptions:
** None
**
** Side Effects:
** None
**
** History:
** 03-Jul-98 (fanra01)
** Rename wts_sess_detach to act_sess_detach.
** 26-Aug-2003 (fanra01)
** Removed explicit memory frees which are part of tagged memory
** free.
*/
GSTATUS
WSMReleaseActSession(
ACT_PSESSION *act_session)
{
GSTATUS err = GSTAT_OK;
ACT_PSESSION session = *act_session;
if (session != NULL)
{
*act_session = NULL;
if (session->name != NULL)
act_sess_detach(session->name);
err = DDFSemOpen(&actSessSemaphore, TRUE);
if (err == GSTAT_OK)
{
if (session->previous != NULL)
session->previous->next = session->next;
else
active_sessions = session->next;
if (session->next != NULL)
session->next->previous = session->previous;
CLEAR_STATUS(DDFSemClose(&actSessSemaphore));
}
CLEAR_STATUS( WSMCleanUserTimeout() );
CLEAR_STATUS( WPSCleanFilesTimeout(NULL) );
CLEAR_STATUS( DBCleanTimeout() );
CLEAR_STATUS(WSFCleanVariable(session->vars));
CLEAR_STATUS (DDFrmhash(&session->vars));
MEfreetag(session->mem_tag);
MEfree((PTR)session);
}
return(err);
}
/*
** Name: WMODocument() - insert, update, delete, select and retrieve documents
**
** Description:
**
** Inputs:
** ACT_PSESSION : active session
** char*[] : list of parameters
**
** Outputs:
** bool* : TRUE is there is something to print
** PTR* : cursor pointer (if NULL means no more information)
**
** Returns:
** GSTATUS : GSTAT_OK
**
** Exceptions:
** None
**
** Side Effects:
** None
**
** History:
** 28-Apr-2000 (fanra01)
** Add additional scheme parameter to WPSrequest.
** 30-Oct-2001 (fanra01)
** Replace ambiguous profile error message with authorization
** and permission messages.
*/
GSTATUS
WMODocument (
ACT_PSESSION act_session,
char* params[],
bool* print,
PTR* user_info)
{
GSTATUS err = GSTAT_OK;
u_i4 action;
u_i4 unit_id = 0;
u_i4 ext_loc = 0;
i4 flag = 0;
u_i4 owner = 0;
u_i4 *pid = NULL;
u_i4 *punit_id = NULL;
i4 *pflag = NULL;
u_i4 *powner = NULL;
u_i4 *pext_loc = NULL;
char *ext_file;
char *ext_suffix;
bool accessible = TRUE;
WPS_FILE *cache = NULL;
bool status;
*print = TRUE;
if (*user_info == NULL)
{
G_ASSERT (params[0] == NULL || params[0][0] == EOS, E_WS0059_WSF_BAD_PARAM);
if (act_session->user_session == NULL)
{
*print = FALSE;
err = DDFStatusAlloc( E_WS0101_WSS_UNAUTHORIZED_USE );
return(err);
}
if (err == GSTAT_OK)
err = WMOTypeAction(params[0], &action);
}
else
action = WSS_ACTION_TYPE_SEL;
if (err == GSTAT_OK)
if (action == WSS_ACTION_TYPE_SEL)
{
if (*user_info == NULL)
{
err = WCSOpenDocument(user_info);
if (err == GSTAT_OK)
err = GAlloc((PTR*)¶ms[1], NUM_MAX_INT_STR, FALSE);
}
if (err == GSTAT_OK)
{
err = WCSGetDocument(
user_info,
&pid,
&punit_id,
¶ms[4],
¶ms[5],
(u_i4**)&pflag,
&powner,
&pext_loc,
¶ms[12],
¶ms[13]);
if (err != GSTAT_OK || *user_info == NULL)
{
CLEAR_STATUS (WCSCloseDocument(user_info));
*print = FALSE;
}
else
{
err = WSSDocAccessibility(act_session->user_session, *pid, WSF_READ_RIGHT, &accessible);
if (err == GSTAT_OK && accessible == TRUE)
{
WSF_CVNA(err, *pid, params[1]);
unit_id = *punit_id;
flag = *pflag;
ext_loc= *pext_loc;
}
else
*print = FALSE;
}
}
}
else
{
u_i4 id;
switch(action)
{
case WSS_ACTION_TYPE_DEL:
case WSS_ACTION_TYPE_RET:
G_ASSERT (params[1] == NULL || CVan(params[1], (i4*)&id) != OK, E_WS0059_WSF_BAD_PARAM);
if (action == WSS_ACTION_TYPE_DEL)
{
err = WSSDocAccessibility(act_session->user_session, id, WSF_DEL_RIGHT, &accessible);
if (err == GSTAT_OK)
if (accessible == TRUE)
err = WCSDeleteDocument (id);
else
err = DDFStatusAlloc( E_WS0065_WSF_UNAUTH_ACCESS );
}
else
{
err = WSSDocAccessibility(act_session->user_session, id, WSF_READ_RIGHT, &accessible);
if (err == GSTAT_OK && accessible == TRUE)
{
err = WCSRetrieveDocument (
id,
&punit_id,
¶ms[4],
¶ms[5],
(u_i4**)&pflag,
&powner,
&pext_loc,
¶ms[12],
¶ms[13]);
if (err == GSTAT_OK && punit_id != NULL)
{
unit_id = *punit_id;
flag = *pflag;
ext_loc= *pext_loc;
owner = *powner;
if (err == GSTAT_OK)
{
err = WPSRequest(
act_session->user_session->name,
act_session->scheme,
act_session->host,
act_session->port,
NULL,
unit_id,
params[4],
params[5],
&cache,
&status);
if (err == GSTAT_OK)
{
if (status == WCS_ACT_LOAD)
{
if ((flag & WCS_EXTERNAL) == FALSE)
err = WCSExtractDocument (cache->file);
if (err == GSTAT_OK)
CLEAR_STATUS(WCSLoaded(cache->file, TRUE))
else
CLEAR_STATUS(WCSLoaded(cache->file, FALSE))
}
if (err == GSTAT_OK)
{
char *tmp = (cache->url == NULL) ? WSF_UNDEFINED : cache->url;
u_i4 length = STlength(tmp) + 1;
err = GAlloc((PTR*)¶ms[10], length, FALSE);
if (err == GSTAT_OK)
MECOPY_VAR_MACRO(tmp, length, params[10]);
}
CLEAR_STATUS(WPSRelease(&cache));
}
}
}
}
else
/*
** Name: Disp_Fname
**
** Decription:
** Takes the string
** content-disposition: form-data; name="xxxx" filename="yyyy"
** opens an ice temporary file and sets items in the variable string
** as xxxx=icetempfile.
**
** Inputs:
** sess ice session structure
** line pointer to the current line
** linelen length of the line
**
** Outputs:
** pos number of characters handled.
**
** Return:
** GSTAT_OK success
** other failure
**
** History:
** 23-Oct-98 (fanra01)
** Created.
*/
static GSTATUS
Disp_Fname (WTS_SESSION* sess, char* line, i4 linelen, i4 * pos)
{
GSTATUS err = GSTAT_OK;
PWTS_UPLOAD load= sess->load;
char* p = line + *pos;
char* name;
i4 remain = linelen - *pos;
i4 i = 0;
i4 j = 0;
UPLOADED_FILE* upload;
if (STbcompare ("name", 4, p, 0, TRUE) == 0)
{
/*
** Find the first quote after name
*/
while ((*p != '\"') && (i < remain))
{
CMbyteinc(i,p);
CMnext(p);
}
CMbyteinc(i,p); /* skip the quote */
CMnext(p);
name= p;
while ((*p != '\"') && (i < remain))
{
j+=CMbytecnt(p);
CMbyteinc(i,p);
CMnext(p);
}
CMbyteinc(i,p);
CMnext(p); /* skip the quote */
while ((*p != ';') && (i < remain))
{
CMbyteinc(i,p);
CMnext(p);
}
CMbyteinc(i,p);
CMnext(p); /* skip the semi colon */
/*
** Allocate space for the variable name a '=' character and an EOS
*/
if ((err = GAlloc (&load->varname, j+2, FALSE)) == GSTAT_OK)
{
MEfill (j+2, 0, load->varname);
MECOPY_VAR_MACRO (name, j, load->varname);
STcat (load->varname, "=");
}
while (CMwhite(p) && (i < remain))
{
CMbyteinc(i, p);
CMnext(p);
}
if (STbcompare ("filename", 8, p, 0, TRUE) == 0)
{
/*
** Find the first quote after filename
*/
while ((*p != '\"') && (i < remain))
{
CMbyteinc(i,p);
CMnext(p);
}
CMbyteinc(i,p);
CMnext(p); /* skip the quote */
name= p;
while ((*p != '\"') && (i < remain))
{
j+=CMbytecnt(p);
CMbyteinc(i,p);
CMnext(p);
}
CMbyteinc(i,p);
CMnext(p); /* skip the quote */
/*
** Allocate space for the filename and an EOS
*/
if ((err = GAlloc (&load->filename, j+1, FALSE)) == GSTAT_OK)
{
MEfill (j+1, 0, load->filename);
MECOPY_VAR_MACRO (name, j, load->filename);
asct_trace( ASCT_LOG )( ASCT_TRACE_PARAMS,
"Upload session=%s file=%s",
((sess->act_session != NULL) ?
((sess->act_session->user_session) ?
sess->act_session->user_session->name : "None")
: "None"),
load->filename );
}
*pos += i;
err = G_ME_REQ_MEM(0, upload, UPLOADED_FILE, 1);
if (err == GSTAT_OK)
{
bool status;
err = WCSRequest( 0, NULL, SYSTEM_ID, NULL, WSF_ICE_SUFFIX,
&upload->file, &status);
if (err == GSTAT_OK)
{
CLEAR_STATUS(WCSLoaded(upload->file, TRUE));
err = WCSOpen (upload->file, "w", SI_BIN, 0);
if (err == GSTAT_OK)
{
i4 nlen = STlength (load->varname);
i4 flen = STlength(upload->file->info->path);
err = GAlloc(&load->icefname, flen + 1, FALSE);
if (err == GSTAT_OK)
{
MECOPY_VAR_MACRO( upload->file->info->path, flen,
load->icefname);
err = GAlloc((PTR*)&sess->variable,
sess->vlen + nlen + flen + 2, TRUE);
if (err == GSTAT_OK && sess->variable != NULL)
{
if (sess->vlen > 0)
{
sess->variable[sess->vlen++] = '&';
}
MECOPY_VAR_MACRO(load->varname, nlen,
sess->variable + sess->vlen);
sess->vlen += nlen;
if (flen)
{
MECOPY_VAR_MACRO(load->icefname, flen,
sess->variable + sess->vlen);
sess->vlen += flen;
upload->next = sess->list;
sess->list = upload;
}
sess->variable[sess->vlen] = EOS;
}
}
}
else
{
CLEAR_STATUS(WCSRelease(&upload->file));
}
}
}
load->state = US_FILE;
}
else
{
HandlerException (sess, line, linelen, pos);
}
}
else
{
HandlerException (sess, line, linelen, pos);
}
return (err);
}
GSTATUS
DDSCloseUserDB (PTR *cursor)
{
CLEAR_STATUS(DDFSemClose(&dds_semaphore));
return(GSTAT_OK);
}
