GSTATUS
DDFSemOpen (
PSEMAPHORE sem,
bool exclusive)
{
GSTATUS err = GSTAT_OK;
STATUS status;
if ((status = CSp_semaphore(TRUE, &sem->semaphore)) == OK)
{
while (status == OK &&
((exclusive == TRUE) ? sem->have != 0 : sem->have < 0))
status = CScnd_wait(&sem->cond, &sem->semaphore);
if (status == OK)
{
if (exclusive == TRUE)
sem->have--;
else
sem->have++;
status = CSv_semaphore(&sem->semaphore);
}
else if (status != E_CS000F_REQUEST_ABORTED)
{
CSv_semaphore(&sem->semaphore);
err = DDFStatusAlloc (E_DF0008_SEM_CANNOT_OPEN);
}
}
return(err);
}
/*
** Name: HandlerException
**
** Decription:
** Function is is to catch unknown or new events.
**
** 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
HandlerException (WTS_SESSION* sess, char* line, i4 linelen, i4 * pos)
{
PWTS_UPLOAD load= sess->load;
load->state = US_END;
return (DDFStatusAlloc(E_WS0088_WTS_INVALID_UPLOAD));
}
GSTATUS
DDFSemCreate (
PSEMAPHORE sem,
char *name)
{
GSTATUS err = GSTAT_OK;
STATUS status;
G_ASSERT(!sem, 1);
status = CSw_semaphore(&(sem->semaphore), CS_SEM_SINGLE, name);
if (status == OK)
status = CScnd_init(&sem->cond);
if (status == OK)
status = CScnd_name(&sem->cond, "DDF R/W semaphore");
sem->have = 0;
if (status != OK)
err = DDFStatusAlloc (E_DF0007_SEM_CANNOT_CREATE);
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);
}
GSTATUS
DDFSemClose (
PSEMAPHORE sem)
{
GSTATUS err = GSTAT_OK;
STATUS status;
G_ASSERT(!sem, E_DF0010_SEM_BAD_INIT);
if ((status = CSp_semaphore(TRUE, &sem->semaphore)) == OK)
{
if (sem->have < 0)
{
sem->have = 0;
/* when releaseing an exclusive - several shares may wake */
status = CScnd_broadcast(&sem->cond);
}
else
{
sem->have--;
if (sem->have == 0)
{
/* when releaseing a share - at most one exclusive may wake */
status = CScnd_signal(&sem->cond, (CS_SID)NULL);
}
}
if (status == OK)
{
if (CSv_semaphore(&sem->semaphore) != OK)
err = DDFStatusAlloc (E_DF0009_SEM_CANNOT_CLOSE);
}
else
{
CSv_semaphore(&sem->semaphore);
}
}
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
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
err = DDFStatusAlloc( E_WS0065_WSF_UNAUTH_ACCESS );
}
break;
case WSS_ACTION_TYPE_INS:
case WSS_ACTION_TYPE_UPD:
{
char *suffix;
G_ASSERT (params[2] == NULL || CVan(params[2], (i4*)&unit_id) != OK, E_WS0059_WSF_BAD_PARAM);
G_ASSERT (params[4] == NULL || params[4][0] == EOS, E_WS0059_WSF_BAD_PARAM);
if (params[5] != NULL)
suffix = params[5];
else
suffix = "";
/*
** Name: ParserGetVariable() -
**
** Description:
**
** Inputs:
** PPARSER_IN in
** PPARSER_OUT out
**
** Outputs:
**
** Returns:
** GSTATUS : GSTAT_OK
**
** Exceptions:
** None
**
** Side Effects:
** None
**
** History:
*/
GSTATUS ParserGetVariable (
PPARSER_IN in,
PPARSER_OUT out)
{
GSTATUS err = GSTAT_OK;
PVAR_PARSER_OUT pout;
u_i4 length;
char* name = NULL;
u_i4 nlen = 0;
char* value = NULL;
u_i4 vlen = 0;
char nullval[] = "";
pout = (PVAR_PARSER_OUT) out;
if (pout->namePos == 0)
{
err = DDFStatusAlloc(E_WS0012_WSS_VAR_BAD_NAME);
}
else
{
length = in->current - in->position;
if (length > 0)
{
u_i4 size = ((((pout->valuePos + length) / 32) + 1) * 32);
err = GAlloc(&pout->value, size, TRUE);
if (err == GSTAT_OK)
{
MECOPY_VAR_MACRO(in->buffer + in->position, length, pout->value + pout->valuePos);
pout->valuePos += length;
}
}
in->position = in->current+1;
if (pout->namePos > 0 && pout->name[0] == VARIABLE_MARK)
err = WSMGetVariable (
pout->act_session,
pout->name + 1,
pout->namePos - 1,
&name,
WSM_SYSTEM | WSM_ACTIVE | WSM_USER);
if (err == GSTAT_OK && name == NULL)
{
name = pout->name;
nlen = pout->namePos;
}
else
nlen = STlength(name);
if (pout->valuePos <= 0)
{
vlen = 1;
value = nullval;
}
else
{
if (pout->value[0] == VARIABLE_MARK)
err = WSMGetVariable (
pout->act_session,
pout->value+ 1,
pout->valuePos - 1,
&value,
WSM_SYSTEM | WSM_ACTIVE | WSM_USER);
if (err == GSTAT_OK && value == NULL)
{
value = pout->value;
vlen = pout->valuePos;
}
else
vlen = STlength(value);
}
err = WSMAddVariable (
pout->act_session,
name,
nlen,
value,
vlen,
pout->type);
}
MEfree((PTR)pout->name);
pout->name = NULL;
MEfree((PTR)pout->value);
pout->value = NULL;
pout->namePos = 0;
pout->valuePos = 0;
return(err);
}
/*
** Name: HandlerError
**
** Decription:
** Function is catch all for states where events are unexpected.
**
** 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
HandlerError (WTS_SESSION* sess, char* line, i4 linelen, i4 * pos)
{
return (DDFStatusAlloc(E_WS0088_WTS_INVALID_UPLOAD));
}
