static void add_vf(char *str)
{
void *p;
if (vf_settings) {
int i = 0;
while (vf_settings[i].name) {
if (!gstrcmp(vf_settings[i++].name, str)) {
i = -1;
break;
}
}
if (i != -1) {
p = realloc(vf_settings, (i + 2) * sizeof(m_obj_settings_t));
if (!p)
return;
vf_settings = p;
vf_settings[i].name = strdup(str);
vf_settings[i].attribs = NULL;
vf_settings[i + 1].name = NULL;
}
} else {
vf_settings = malloc(2 * sizeof(m_obj_settings_t));
vf_settings[0].name = strdup(str);
vf_settings[0].attribs = NULL;
vf_settings[1].name = NULL;
}
mp_msg(MSGT_GPLAYER, MSGL_INFO, MSGTR_AddingVideoFilter, str);
}
static int websHomePageHandler(webs_t wp, char_t *urlPrefix, char_t *webDir,
int arg, char_t *url, char_t *path, char_t *query)
{
/*
* If the empty or "/" URL is invoked, redirect default URLs to the home page
*/
if (*url == '\0' || gstrcmp(url, T("/")) == 0) {
websRedirect(wp, T("home.asp"));
return 1;
}
return 0;
}
static char_t *umGetNextRowData(char_t *tableName, char_t *columnName,
char_t *keyLast)
{
char_t *key;
int row;
int check;
a_assert(tableName && *tableName);
a_assert(columnName && *columnName);
a_assert(keyLast && *keyLast);
/*
* Position row counter to row where the given key value was found
*/
row = 0;
key = NULL;
while ((((check = dbReadStr(didUM, tableName, columnName, row++,
&key)) == 0) || (check == DB_ERR_ROW_DELETED)) &&
((key == NULL) || (gstrcmp(key, keyLast) != 0))) {
}
/*
* If the last key value was not found, return NULL
*/
if (!key || gstrcmp(key, keyLast) != 0) {
return NULL;
}
/*
* Move through table until we retrieve the next row with a non-null key
*/
while (((check = dbReadStr(didUM, tableName, columnName, row++, &key))
== 0) || (check == DB_ERR_ROW_DELETED)) {
if (key && *key && (gstrcmp(key, keyLast) != 0)) {
return key;
}
}
return NULL;
}
static int websHomePageHandler(webs_t wp, char_t *urlPrefix, char_t *webDir,
int arg, char_t *url, char_t *path, char_t *query)
{
// fprintf(stderr, "prefix(%s),webDir(%s),url(%s), path(%s), query(%s)\n",
// urlPrefix,webDir,url,path,query);
// fprintf(stderr, "Default Home(%s)\n", WEBS_DEFAULT_HOME);
/*
* If the empty or "/" URL is invoked, redirect default URLs to the home page
*/
if (*url == '\0' || gstrcmp(url, T("/")) == 0) {
websRedirect(wp, WEBS_DEFAULT_HOME);
return 1;
}
return 0;
}
int symDelete(sym_fd_t sd, char_t *name)
{
sym_tabent_t *tp;
sym_t *sp, *last;
char_t *cp;
int hindex;
a_assert(name && *name);
a_assert(0 <= sd && sd < symMax);
tp = sym[sd];
a_assert(tp);
/*
* Calculate the first daisy-chain from the hash table. If non-zero, then
* we have daisy-chain, so scan it and look for the symbol.
*/
last = NULL;
hindex = hashIndex(tp, name);
if ((sp = tp->hash_table[hindex]) != NULL) {
for ( ; sp; sp = sp->forw) {
cp = sp->name.value.string;
if (cp[0] == name[0] && gstrcmp(cp, name) == 0) {
break;
}
last = sp;
}
}
if (sp == (sym_t*) NULL) { /* Not Found */
return -1;
}
/*
* Unlink and free the symbol. Last will be set if the element to be deleted
* is not first in the chain.
*/
if (last) {
last->forw = sp->forw;
} else {
tp->hash_table[hindex] = sp->forw;
}
valueFree(&sp->name);
valueFree(&sp->content);
bfree(B_L, (void*) sp);
return 0;
}
static int GetColumnIndex(int tid, char_t *colName)
{
int column;
dbTable_t *pTable;
a_assert(colName);
if ((tid >= 0) && (tid < dbMaxTables) && (dbListTables[tid] != NULL)) {
pTable = dbListTables[tid];
for (column = 0; (column < pTable->nColumns); column++) {
if (gstrcmp(colName, pTable->columnNames[column]) == 0)
return column;
}
}
return -1;
}
static void remove_vf( char * str )
{
int n = 0;
if ( !vf_settings ) return;
mp_msg( MSGT_GPLAYER,MSGL_STATUS,MSGTR_RemovingVideoFilter,str );
while ( vf_settings[n++].name ); n--;
if ( n > -1 )
{
int i = 0,m = -1;
while ( vf_settings[i].name ) if ( !gstrcmp( vf_settings[i++].name,str ) ) { m=i - 1; break; }
i--;
if ( m > -1 )
{
if ( n == 1 ) { free( vf_settings[0].name );free( vf_settings[0].attribs ); free( vf_settings ); vf_settings=NULL; }
else { free( vf_settings[i].name );free( vf_settings[i].attribs ); memcpy( &vf_settings[i],&vf_settings[i + 1],( n - i ) * sizeof( m_obj_settings_t ) ); }
}
}
}
int websValidateUrl(webs_t wp, char_t *path)
{
char_t *parts[64]; /* Array of ptr's to URL parts */
char_t *token, *dir, *lpath;
int i, len, npart;
a_assert(websValid(wp));
a_assert(path);
dir = websGetRequestDir(wp);
if (dir == NULL || *dir == '\0') {
return -1;
}
/*
* Copy the string so we don't destroy the original
*/
path = bstrdup(B_L, path);
websDecodeUrl(path, path, gstrlen(path));
len = npart = 0;
parts[0] = NULL;
/*
* 22 Jul 02 -- there were reports that a directory traversal exploit was
* possible in the WebServer running under Windows if directory paths
* outside the server's specified root web were given by URL-encoding the
* backslash character, like:
*
* GoAhead is vulnerable to a directory traversal bug. A request such as
*
* GoAhead-server/../../../../../../../ results in an error message
* 'Cannot open URL'.
* However, by encoding the '/' character, it is possible to break out of
* the
* web root and read arbitrary files from the server.
* Hence a request like:
*
* GoAhead-server/..%5C..%5C..%5C..%5C..%5C..%5C/winnt/win.ini returns the
* contents of the win.ini file.
* (Note that the description uses forward slashes (0x2F), but the example
* uses backslashes (0x5C). In my tests, forward slashes are correctly
* trapped, but backslashes are not. The code below substitutes forward
* slashes for backslashes before attempting to validate that there are no
* unauthorized paths being accessed.
*/
token = gstrchr(path, '\\');
while (token != NULL)
{
*token = '/';
token = gstrchr(token, '\\');
}
token = gstrtok(path, T("/"));
/*
* Look at each directory segment and process "." and ".." segments
* Don't allow the browser to pop outside the root web.
*/
while (token != NULL) {
if (gstrcmp(token, T("..")) == 0) {
if (npart > 0) {
npart--;
}
} else if (gstrcmp(token, T(".")) != 0) {
parts[npart] = token;
len += gstrlen(token) + 1;
npart++;
}
token = gstrtok(NULL, T("/"));
}
/*
* Create local path for document. Need extra space all "/" and null.
*/
if (npart || (gstrcmp(path, T("/")) == 0) || (path[0] == '\0')) {
lpath = balloc(B_L, (gstrlen(dir) + 1 + len + 1) * sizeof(char_t));
gstrcpy(lpath, dir);
for (i = 0; i < npart; i++) {
gstrcat(lpath, T("/"));
gstrcat(lpath, parts[i]);
}
websSetRequestLpath(wp, lpath);
bfree(B_L, path);
bfree(B_L, lpath);
} else {
bfree(B_L, path);
return -1;
}
return 0;
}
/**
* @brief Manage playlists and URL lists.
*
* @param cmd task to be performed
* @param data list item for the task
*
* @return pointer to top of list (GET command),
* pointer to current list item (ITEM command) or
* NULL (DELETE or unknown command)
*
* @note PLAYLIST_ITEM_GET_POS returns the position number as pointer value
* (if @a data is NULL the last position number, i.e. number of items),
* and position 0 means "not found"
*/
void *listMgr(int cmd, void *data)
{
uintptr_t pos;
plItem *pdat = (plItem *)data;
urlItem *udat = (urlItem *)data;
switch (cmd) {
/* playlist */
case PLAYLIST_GET:
return plList;
case PLAYLIST_ITEM_APPEND:
if (plList) {
plItem *item = plList;
while (item->next)
item = item->next;
item->next = pdat;
pdat->prev = item;
pdat->next = NULL;
} else {
pdat->next = pdat->prev = NULL;
plCurrent = plList = pdat;
}
return plCurrent;
case PLAYLIST_ITEM_INSERT:
if (plCurrent) {
pdat->next = plCurrent->next;
if (pdat->next)
pdat->next->prev = pdat;
pdat->prev = plCurrent;
plCurrent->next = pdat;
plCurrent = pdat;
return plCurrent;
} else
return listMgr(PLAYLIST_ITEM_APPEND, pdat);
case PLAYLIST_ITEM_FIND:
if (plList) {
plItem *item = plList;
do {
if (gstrcmp(item->path, pdat->path) == 0 && gstrcmp(item->name, pdat->name) == 0)
return item;
item = item->next;
} while (item);
}
return NULL;
case PLAYLIST_ITEM_SET_CURR:
plCurrent = pdat;
return plCurrent;
case PLAYLIST_ITEM_GET_CURR:
return plCurrent;
case PLAYLIST_ITEM_GET_POS:
pos = 0;
if (plList) {
uintptr_t i = 0;
plItem *item = plList;
do {
i++;
if (item == pdat) {
pos = i;
break;
}
item = item->next;
} while (item);
if (!pdat)
pos = i;
}
return (void *)pos;
case PLAYLIST_ITEM_GET_PREV:
if (plCurrent && plCurrent->prev) {
plCurrent = plCurrent->prev;
return plCurrent;
}
return NULL;
case PLAYLIST_ITEM_GET_NEXT:
if (plCurrent && plCurrent->next) {
plCurrent = plCurrent->next;
return plCurrent;
}
return NULL;
case PLAYLIST_ITEM_GET_LAST:
if (plList) {
plItem *item = plList;
while (item->next)
item = item->next;
return item;
}
return NULL;
case PLAYLIST_ITEM_DEL_CURR:
if (plCurrent) {
plItem *curr = plCurrent;
if (curr->prev)
curr->prev->next = curr->next;
if (curr->next)
curr->next->prev = curr->prev;
plCurrent = curr->next;
if (curr == plList)
plList = plCurrent;
free(curr->path);
free(curr->name);
free(curr->title);
free(curr);
}
return plCurrent;
case PLAYLIST_DELETE:
while (plList) {
plItem *item = plList->next;
free(plList->path);
free(plList->name);
free(plList->title);
free(plList);
plList = item;
}
plCurrent = NULL;
return NULL;
/* URL list */
case URLLIST_GET:
return urlList;
case URLLIST_ITEM_ADD:
if (urlList) {
urlItem *item = urlList;
while (item) {
if (strcmp(udat->url, item->url) == 0) {
free(udat->url);
free(udat);
return NULL;
}
if (item->next)
item = item->next;
else {
item->next = udat;
udat->next = NULL;
break;
}
}
} else {
udat->next = NULL;
urlList = udat;
}
return udat;
case URLLIST_DELETE:
while (urlList) {
urlItem *item = urlList->next;
free(urlList->url);
free(urlList);
urlList = item;
}
return NULL;
default:
return NULL;
}
}
static void bStatsAlloc(B_ARGS_DEC, void *ptr, int q, int size)
{
int memSize;
bStatsFileType *fp;
bStatsBlkType *bp;
char_t name[FNAMESIZE + 10];
gsprintf(name, T("%s:%d"), B_ARGS);
bStats[q].alloc++;
bStats[q].inuse++;
bStatsMemInUse += size;
if (bStatsMemInUse > bStatsMemMax) {
bStatsMemMax = bStatsMemInUse;
}
memSize = (1 << (B_SHIFT + q)) + sizeof(bType);
bStatsBallocInUse += memSize;
if (bStatsBallocInUse > bStatsBallocMax) {
bStatsBallocMax = bStatsBallocInUse;
}
/*
* Track maximum stack usage. Assumes a stack growth down. Approximate as
* we only measure this on block allocation.
*/
if ((void*) &file < bStackMin) {
bStackMin = (void*) &file;
}
/*
* Find the file and adjust the stats for this file
*/
for (fp = bStatsFiles; fp < &bStatsFiles[bStatsFilesMax]; fp++) {
if (fp->file[0] == file[0] && gstrcmp(fp->file, name) == 0) {
fp->allocated += size;
fp->count++;
fp->times++;
if (fp->largest < size) {
fp->largest = size;
fp->q = q;
}
break;
}
}
/*
* New entry: find the first free slot and create a new entry
*/
if (fp >= &bStatsFiles[bStatsFilesMax]) {
for (fp = bStatsFiles; fp < &bStatsFiles[B_MAX_FILES]; fp++) {
if (fp->file[0] == '\0') {
gstrncpy(fp->file, name, TSZ(fp->file));
fp->allocated += size;
fp->count++;
fp->times++;
fp->largest = size;
fp->q = q;
if ((fp - bStatsFiles) >= bStatsFilesMax) {
bStatsFilesMax = (fp - bStatsFiles) + 1;
}
break;
}
}
}
/*
* Update the per block stats. Allocate a new slot.
*/
for (bp = bStatsBlks; bp < &bStatsBlks[B_MAX_BLOCKS]; bp++) {
if (bp->ptr == NULL) {
bp->ptr = ptr;
bp->who = fp;
if ((bp - bStatsBlks) >= bStatsBlksMax) {
bStatsBlksMax = (bp - bStatsBlks) + 1;
}
break;
}
}
}
int websValidateUrl(webs_t wp, char_t *path)
{
/*
Thanks to Dhanwa T ([email protected]) for this fix -- previously,
if an URL was requested having more than (the hardcoded) 64 parts,
the webServer would experience a hard crash as it attempted to
write past the end of the array 'parts'.
Also fixes: http://www.securiteam.com/securitynews/5MP0C1580W.html
*/
char_t *parts[MAX_URL_DEPTH]; /* Array of ptr's to URL parts */
char_t *token, *dir, *lpath;
int i, len, npart;
a_assert(websValid(wp));
a_assert(path);
dir = websGetRequestDir(wp);
if (dir == NULL || *dir == '\0') {
return -1;
}
/*
* Copy the string so we don't destroy the original
*/
path = bstrdup(B_L, path);
websDecodeUrl(path, path, gstrlen(path));
len = npart = 0;
parts[0] = NULL;
/*
* Fixed by Matt Moore, 22 Jul 02
* http://www.securiteam.com/securitynews/5RP0I007PG.html
* http://www.securiteam.com/securitynews/5QP010U3FS.html
*
* There were reports that a directory traversal exploit was
* possible in the WebServer running under Windows if directory paths
* outside the server's specified root web were given by URL-encoding the
* backslash character, like:
*
* GoAhead is vulnerable to a directory traversal bug. A request such as
*
* GoAhead-server/../../../../../../../ results in an error message
* 'Cannot open URL'.
* However, by encoding the '/' character, it is possible to break out of
* the web root and read arbitrary files from the server.
* Hence a request like:
*
* GoAhead-server/..%5C..%5C..%5C..%5C..%5C..%5C/winnt/win.ini returns the
* contents of the win.ini file.
* (Note that the description uses forward slashes (0x2F), but the example
* uses backslashes (0x5C). In my tests, forward slashes are correctly
* trapped, but backslashes are not. The code below substitutes forward
* slashes for backslashes before attempting to validate that there are no
* unauthorized paths being accessed.
*/
token = gstrchr(path, '\\');
while (token != NULL) {
*token = '/';
token = gstrchr(token, '\\');
}
token = gstrtok(path, T("/"));
/*
* Look at each directory segment and process "." and ".." segments
* Don't allow the browser to pop outside the root web.
*/
while (token != NULL)
{
if (npart >= MAX_URL_DEPTH)
{
/*
* malformed URL -- too many parts for us to process.
*/
bfree(B_L, path);
return -1;
}
if (gstrcmp(token, T("..")) == 0)
{
if (npart > 0)
{
npart--;
}
} else if (gstrcmp(token, T(".")) != 0) {
parts[npart] = token;
len += gstrlen(token) + 1;
npart++;
}
token = gstrtok(NULL, T("/"));
}
#ifdef WIN32
if (isBadWindowsPath(parts, npart))
{
bfree(B_L, path);
return -1;
}
#endif
/*
* Create local path for document. Need extra space all "/" and null.
*/
if (npart || (gstrcmp(path, T("/")) == 0) || (path[0] == '\0')) {
lpath = balloc(B_L, (gstrlen(dir) + 1 + len + 1) * sizeof(char_t));
gstrcpy(lpath, dir);
for (i = 0; i < npart; i++) {
gstrcat(lpath, T("/"));
gstrcat(lpath, parts[i]);
}
websSetRequestLpath(wp, lpath);
bfree(B_L, path);
bfree(B_L, lpath);
} else {
bfree(B_L, path);
return -1;
}
return 0;
}
/*
* Process a form request. Returns 1 always to indicate it handled the URL
*/
int websCgiHandler(webs_t wp, char_t *urlPrefix, char_t *webDir, int arg,
char_t *url, char_t *path, char_t* query)
{
cgiRec *cgip;
sym_t *s;
char_t cgiBuf[FNAMESIZE], *stdIn, *stdOut, cwd[FNAMESIZE];
char_t *cp, *cgiName, *cgiPath, **argp, **envp, **ep;
int n, envpsize, argpsize, pHandle, cid;
a_assert(websValid(wp));
a_assert(url && *url);
a_assert(path && *path == '/');
websStats.cgiHits++;
/*
* Extract the form name and then build the full path name. The form
* name will follow the first '/' in path.
*/
gstrncpy(cgiBuf, path, TSZ(cgiBuf));
if ((cgiName = gstrchr(&cgiBuf[1], '/')) == NULL) {
websError(wp, 200, T("Missing CGI name"));
return 1;
}
cgiName++;
if ((cp = gstrchr(cgiName, '/')) != NULL) {
*cp = '\0';
}
fmtAlloc(&cgiPath, FNAMESIZE, T("%s/%s/%s"), websGetDefaultDir(),
CGI_BIN, cgiName);
#ifndef VXWORKS
/*
* See if the file exists and is executable. If not error out.
* Don't do this step for VxWorks, since the module may already
* be part of the OS image, rather than in the file system.
*/
{
gstat_t sbuf;
if (gstat(cgiPath, &sbuf) != 0 || (sbuf.st_mode & S_IFREG) == 0) {
websError(wp, 200, T("CGI process file does not exist"));
bfree(B_L, cgiPath);
return 1;
}
#if (defined (WIN) || defined (CE))
if (gstrstr(cgiPath, T(".exe")) == NULL &&
gstrstr(cgiPath, T(".bat")) == NULL) {
#elif (defined (NW))
if (gstrstr(cgiPath, T(".nlm")) == NULL) {
#else
if (gaccess(cgiPath, X_OK) != 0) {
#endif /* WIN || CE */
websError(wp, 200, T("CGI process file is not executable"));
bfree(B_L, cgiPath);
return 1;
}
}
#endif /* ! VXWORKS */
/*
* Get the CWD for resetting after launching the child process CGI
*/
ggetcwd(cwd, FNAMESIZE);
/*
* Retrieve the directory of the child process CGI
*/
if ((cp = gstrrchr(cgiPath, '/')) != NULL) {
*cp = '\0';
gchdir(cgiPath);
*cp = '/';
}
/*
* Build command line arguments. Only used if there is no non-encoded
* = character. This is indicative of a ISINDEX query. POST separators
* are & and others are +. argp will point to a balloc'd array of
* pointers. Each pointer will point to substring within the
* query string. This array of string pointers is how the spawn or
* exec routines expect command line arguments to be passed. Since
* we don't know ahead of time how many individual items there are in
* the query string, the for loop includes logic to grow the array
* size via brealloc.
*/
argpsize = 10;
argp = balloc(B_L, argpsize * sizeof(char_t *));
*argp = cgiPath;
n = 1;
if (gstrchr(query, '=') == NULL) {
websDecodeUrl(query, query, gstrlen(query));
for (cp = gstrtok(query, T(" ")); cp != NULL; ) {
*(argp+n) = cp;
n++;
if (n >= argpsize) {
argpsize *= 2;
argp = brealloc(B_L, argp, argpsize * sizeof(char_t *));
}
cp = gstrtok(NULL, T(" "));
}
}
*(argp+n) = NULL;
/*
* Add all CGI variables to the environment strings to be passed
* to the spawned CGI process. This includes a few we don't
* already have in the symbol table, plus all those that are in
* the cgiVars symbol table. envp will point to a balloc'd array of
* pointers. Each pointer will point to a balloc'd string containing
* the keyword value pair in the form keyword=value. Since we don't
* know ahead of time how many environment strings there will be the
* for loop includes logic to grow the array size via brealloc.
*/
envpsize = WEBS_SYM_INIT;
envp = balloc(B_L, envpsize * sizeof(char_t *));
n = 0;
fmtAlloc(envp+n, FNAMESIZE, T("%s=%s"),T("PATH_TRANSLATED"), cgiPath);
n++;
fmtAlloc(envp+n, FNAMESIZE, T("%s=%s/%s"),T("SCRIPT_NAME"),
CGI_BIN, cgiName);
n++;
fmtAlloc(envp+n, FNAMESIZE, T("%s=%s"),T("REMOTE_USER"), wp->userName);
n++;
fmtAlloc(envp+n, FNAMESIZE, T("%s=%s"),T("AUTH_TYPE"), wp->authType);
n++;
for (s = symFirst(wp->cgiVars); s != NULL; s = symNext(wp->cgiVars)) {
if (s->content.valid && s->content.type == string &&
gstrcmp(s->name.value.string, T("REMOTE_HOST")) != 0 &&
gstrcmp(s->name.value.string, T("HTTP_AUTHORIZATION")) != 0) {
fmtAlloc(envp+n, FNAMESIZE, T("%s=%s"), s->name.value.string,
s->content.value.string);
n++;
if (n >= envpsize) {
envpsize *= 2;
envp = brealloc(B_L, envp, envpsize * sizeof(char_t *));
}
}
}
if (wp->flags & WEBS_CGI_UPLOAD){
// set filename into enviornment variables
fmtAlloc(envp+n, FNAMESIZE, T("%s=%s"), T("UPLOAD_FILENAME"), wp->cgiStdin);
n++;
}
*(envp+n) = NULL;
/*
* Create temporary file name(s) for the child's stdin and stdout.
* For POST data the stdin temp file (and name) should already exist.
*/
if (wp->cgiStdin == NULL) {
wp->cgiStdin = websGetCgiCommName(wp);
}
stdIn = wp->cgiStdin;
stdOut = websGetCgiCommName(wp);
/*
* Now launch the process. If not successful, do the cleanup of resources.
* If successful, the cleanup will be done after the process completes.
*/
if ((pHandle = websLaunchCgiProc(cgiPath, argp, envp, stdIn, stdOut))
== -1) {
websError(wp, 200, T("failed to spawn CGI task"));
for (ep = envp; *ep != NULL; ep++) {
bfreeSafe(B_L, *ep);
}
bfreeSafe(B_L, cgiPath);
bfreeSafe(B_L, argp);
bfreeSafe(B_L, envp);
bfreeSafe(B_L, stdOut);
} else {
/*
* If the spawn was successful, put this wp on a queue to be
* checked for completion.
*/
cid = hAllocEntry((void***) &cgiList, &cgiMax, sizeof(cgiRec));
cgip = cgiList[cid];
cgip->handle = pHandle;
cgip->stdIn = stdIn;
cgip->stdOut = stdOut;
cgip->cgiPath = cgiPath;
cgip->argp = argp;
cgip->envp = envp;
cgip->wp = wp;
cgip->fplacemark = 0;
websTimeoutCancel(wp);
}
/*
* Restore the current working directory after spawning child CGI
*/
gchdir(cwd);
return 1;
}
/******************************************************************************/
/*
* Any entry in the cgiList need to be checked to see if it has
*/
void websCgiGatherOutput (cgiRec *cgip)
{
gstat_t sbuf;
char_t cgiBuf[FNAMESIZE];
if ((gstat(cgip->stdOut, &sbuf) == 0) &&
(sbuf.st_size > cgip->fplacemark)) {
int fdout;
fdout = gopen(cgip->stdOut, O_RDONLY | O_BINARY, 0444 );
/*
* Check to see if any data is available in the
* output file and send its contents to the socket.
*/
if (fdout >= 0) {
webs_t wp = cgip->wp;
int nRead;
/*
* Write the HTTP header on our first pass
*/
if (cgip->fplacemark == 0) {
websWrite(wp, T("HTTP/1.0 200 OK\r\n"));
}
glseek(fdout, cgip->fplacemark, SEEK_SET);
while ((nRead = gread(fdout, cgiBuf, FNAMESIZE)) > 0) {
websWriteBlock(wp, cgiBuf, nRead);
cgip->fplacemark += nRead;
}
gclose(fdout);
}
}
}
/******************************************************************************/
/*
* Any entry in the cgiList need to be checked to see if it has
* completed, and if so, process its output and clean up.
*/
void websCgiCleanup()
{
cgiRec *cgip;
webs_t wp;
char_t **ep;
int cid, nTries;
for (cid = 0; cid < cgiMax; cid++) {
if ((cgip = cgiList[cid]) != NULL) {
int exit_status;
wp = cgip->wp;
websCgiGatherOutput (cgip);
if ( websCheckCgiProc(cgip->handle, &exit_status) == 0) {
/*
* We get here if the CGI process has terminated. Clean up.
*/
nTries = 0;
/*
* Make sure we didn't miss something during a task switch.
* Maximum wait is 100 times 10 msecs (1 second).
*/
while ((cgip->fplacemark == 0) && (nTries < 100)) {
websCgiGatherOutput(cgip);
/*
* There are some cases when we detect app exit
* before the file is ready.
*/
if (cgip->fplacemark == 0) {
#ifdef WIN
Sleep(10);
#endif /* WIN*/
}
nTries++;
}
if (cgip->fplacemark == 0) {
websError(wp, 200, T("CGI generated no output"));
} else {
websDone(wp, 200);
}
/*
* Remove the temporary re-direction files
*/
gunlink(cgip->stdIn);
gunlink(cgip->stdOut);
/*
* Free all the memory buffers pointed to by cgip.
* The stdin file name (wp->cgiStdin) gets freed as
* part of websFree().
*/
cgiMax = hFree((void***) &cgiList, cid);
for (ep = cgip->envp; ep != NULL && *ep != NULL; ep++) {
bfreeSafe(B_L, *ep);
}
bfreeSafe(B_L, cgip->cgiPath);
bfreeSafe(B_L, cgip->argp);
bfreeSafe(B_L, cgip->envp);
bfreeSafe(B_L, cgip->stdOut);
bfreeSafe(B_L, cgip);
#if 0 //DAVIDM - we do not want this, netflash does it for us
if(wp->has_firmware_upload_clean){
if (WIFEXITED(exit_status) && WEXITSTATUS(exit_status) != 0)
return;
sync();
doSystem("sleep 3 && reboot &");
}
#endif
}
}
}
}
/**
* @brief Issue a command to the GUI.
*
* @note The GUI is controlled by giving it commands.
*
* @param what command to be performed
* @param data pointer to data needed for the command
*
* @return #True (ok) or #False (error)
*/
int gui(int what, void *data)
{
static float last_balance = -1.0f;
#ifdef CONFIG_DVDREAD
dvd_priv_t *dvd;
#endif
int idata = (intptr_t)data, msg, state;
stream_t *stream = NULL;
sh_audio_t *sh_audio;
mixer_t *mixer;
float l, r, b;
plItem *next = NULL;
switch (what) {
case GUI_SET_CONTEXT:
guiInfo.mpcontext = data;
break;
case GUI_SET_STATE:
switch (idata) {
case GUI_STOP:
case GUI_PLAY:
// if ( !gtkShowVideoWindow ) wsWindowVisibility( &guiApp.videoWindow,wsHideWindow );
case GUI_PAUSE:
guiInfo.Playing = idata;
break;
}
uiState();
break;
case GUI_REDRAW:
uiEvent(ivRedraw, 0);
if (!guiInfo.Playing || !guiInfo.VideoWindow)
wsEvents();
/* else it's handled by the vo driver calling GUI_HANDLE_X_EVENT */
wsMouseAutohide();
gtkEvents();
break;
case GUI_RUN_COMMAND:
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[interface] GUI_RUN_COMMAND: %d\n", idata);
switch (idata) {
case MP_CMD_VO_FULLSCREEN:
uiEvent(evFullScreen, True);
break;
case MP_CMD_PLAY_TREE_STEP:
uiEvent(evNext, 0);
break;
case -MP_CMD_PLAY_TREE_STEP:
uiEvent(evPrev, 0);
break;
case MP_CMD_STOP:
uiEvent(evStop, 0);
break;
case MP_CMD_QUIT:
uiEvent(evExit, 0);
break;
}
break;
case GUI_RUN_MESSAGE:
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[interface] GUI_RUN_MESSAGE: %s\n", (const char *)data);
msg = appFindMessage((const char *)data);
if ((msg == evMenu) || appFindItem(msg))
uiEvent(msg, 0);
break;
case GUI_PREPARE:
uiEvent(ivRedraw, True);
wsMouseVisibility(&guiApp.videoWindow, wsHideMouseCursor);
usec_sleep(20000);
wsEvents();
if (guiInfo.MediumChanged == GUI_MEDIUM_NEW) {
audio_id = -1;
video_id = -1;
dvdsub_id = -1;
vobsub_id = -1;
stream_cache_size = -1;
autosync = 0;
force_fps = 0;
}
switch (guiInfo.StreamType) {
case STREAMTYPE_FILE:
case STREAMTYPE_STREAM:
filename = guiInfo.Filename;
break;
case STREAMTYPE_CDDA:
{
char tmp[512];
sprintf(tmp, "cdda://%d", guiInfo.Track);
uiSetFile(NULL, tmp, SAME_STREAMTYPE);
}
break;
case STREAMTYPE_VCD:
{
char tmp[512];
sprintf(tmp, "vcd://%d", guiInfo.Track);
uiSetFile(NULL, tmp, SAME_STREAMTYPE);
}
break;
case STREAMTYPE_DVD:
{
char tmp[512];
sprintf(tmp, "dvd://%d", guiInfo.Track);
uiSetFile(NULL, tmp, SAME_STREAMTYPE);
}
#ifdef CONFIG_DVDREAD
dvd_chapter = guiInfo.Chapter;
dvd_angle = guiInfo.Angle;
#endif
break;
case STREAMTYPE_TV:
case STREAMTYPE_DVB:
{
char tmp[512];
sprintf(tmp, "%s://", guiTV[gui_tv_digital].SchemeName);
uiSetFile(NULL, tmp, SAME_STREAMTYPE);
}
}
/* video opts */
if (!video_driver_list) {
int i = 0;
while (video_out_drivers[i++]) {
if (video_out_drivers[i - 1]->control(VOCTRL_GUISUPPORT, NULL) == VO_TRUE) {
listSet(&video_driver_list, video_out_drivers[i - 1]->info->short_name);
break;
}
}
}
if (!video_driver_list && !video_driver_list[0]) {
gmp_msg(MSGT_GPLAYER, MSGL_FATAL, MSGTR_GUI_MSG_VideoOutError);
mplayer(MPLAYER_EXIT_GUI, EXIT_ERROR, 0);
}
{
int i = 0;
guiInfo.VideoWindow = False;
while (video_out_drivers[i++]) {
if ((video_driver_list && !gstrcmp(video_driver_list[0], video_out_drivers[i - 1]->info->short_name)) && (video_out_drivers[i - 1]->control(VOCTRL_GUISUPPORT, NULL) == VO_TRUE)) {
guiInfo.VideoWindow = True;
break;
}
}
}
if (video_driver_list && !gstrcmp(video_driver_list[0], "dxr3"))
if (guiInfo.StreamType != STREAMTYPE_DVD && guiInfo.StreamType != STREAMTYPE_VCD)
if (gtkVfLAVC)
add_vf("lavc", NULL);
if (gtkVfPP)
add_vf("pp", NULL);
switch (guiInfo.Rotation) {
static const char *argvf[] = { "_oldargs_", NULL, NULL };
case -1:
remove_vf("rotate");
remove_vf("flip");
remove_vf("mirror");
break;
case 1:
argvf[1] = "1";
add_vf("rotate", argvf);
remove_vf("flip");
remove_vf("mirror");
break;
case 2:
argvf[1] = "2";
add_vf("rotate", argvf);
remove_vf("flip");
remove_vf("mirror");
break;
case 8:
remove_vf("rotate");
add_vf("flip", NULL);
add_vf("mirror", NULL);
break;
}
/* audio opts */
// if ( ao_plugin_cfg.plugin_list ) { free( ao_plugin_cfg.plugin_list ); ao_plugin_cfg.plugin_list=NULL; }
if (gtkAONorm)
listRepl(&af_cfg.list, "volnorm", "volnorm");
if (gtkEnableAudioEqualizer)
listRepl(&af_cfg.list, "equalizer", "equalizer");
if (gtkAOExtraStereo) {
char *name;
name = malloc(12 + 20 + 1);
snprintf(name, 12 + 20, "extrastereo=%f", gtkAOExtraStereoMul);
name[12 + 20] = 0;
listRepl(&af_cfg.list, "extrastereo", name);
free(name);
}
if (audio_driver_list && !gstrncmp(audio_driver_list[0], "oss", 3)) {
mixer_device = gtkAOOSSMixer;
mixer_channel = gtkAOOSSMixerChannel;
if (gtkAOOSSDevice) {
char *tmp;
tmp = calloc(1, strlen(gtkAOOSSDevice) + 7);
sprintf(tmp, "oss:%s", gtkAOOSSDevice);
listSet(&audio_driver_list, tmp);
free(tmp);
}
}
if (audio_driver_list && !gstrncmp(audio_driver_list[0], "alsa", 4)) {
mixer_device = gtkAOALSAMixer;
mixer_channel = gtkAOALSAMixerChannel;
if (gtkAOALSADevice) {
char *tmp;
tmp = calloc(1, strlen(gtkAOALSADevice) + 14);
sprintf(tmp, "alsa:device=%s", gtkAOALSADevice);
listSet(&audio_driver_list, tmp);
free(tmp);
}
}
if (audio_driver_list && !gstrncmp(audio_driver_list[0], "sdl", 3)) {
if (gtkAOSDLDriver) {
char *tmp;
tmp = calloc(1, strlen(gtkAOSDLDriver) + 10);
sprintf(tmp, "sdl:%s", gtkAOSDLDriver);
listSet(&audio_driver_list, tmp);
free(tmp);
}
}
if (audio_driver_list && !gstrncmp(audio_driver_list[0], "esd", 3)) {
if (gtkAOESDDevice) {
char *tmp;
tmp = calloc(1, strlen(gtkAOESDDevice) + 10);
sprintf(tmp, "esd:%s", gtkAOESDDevice);
listSet(&audio_driver_list, tmp);
free(tmp);
}
}
/* subtitle */
// subdata->filename=gstrdup( guiInfo.SubtitleFilename );
stream_dump_type = 0;
if (gtkSubDumpMPSub)
stream_dump_type = 4;
if (gtkSubDumpSrt)
stream_dump_type = 6;
gtkSubDumpMPSub = gtkSubDumpSrt = False;
/* misc */
if (gtkCacheOn)
stream_cache_size = gtkCacheSize;
if (gtkAutoSyncOn)
autosync = gtkAutoSync;
if (guiInfo.AudioFilename)
audio_stream = gstrdup(guiInfo.AudioFilename);
else if (guiInfo.MediumChanged == GUI_MEDIUM_NEW)
nfree(audio_stream);
// audio_stream = NULL;
guiInfo.MediumChanged = False;
ass_enabled = gtkASS.enabled;
ass_use_margins = gtkASS.use_margins;
ass_top_margin = gtkASS.top_margin;
ass_bottom_margin = gtkASS.bottom_margin;
break;
case GUI_SET_STREAM:
if (guiInfo.StreamType == STREAMTYPE_PLAYLIST)
guiInfo.mpcontext->file_format = DEMUXER_TYPE_PLAYLIST;
else {
stream = data;
guiInfo.StreamType = stream->type;
}
switch (guiInfo.StreamType) {
case STREAMTYPE_FILE:
case STREAMTYPE_STREAM:
guiInfo.Tracks = (uintptr_t)listMgr(PLAYLIST_ITEM_GET_POS, 0);
break;
case STREAMTYPE_CDDA:
guiInfo.Tracks = 0;
stream_control(stream, STREAM_CTRL_GET_NUM_TITLES, &guiInfo.Tracks);
if (stream_control(stream, STREAM_CTRL_GET_CURRENT_TITLE, &guiInfo.Track) == STREAM_OK)
guiInfo.Track++;
break;
case STREAMTYPE_VCD:
guiInfo.Tracks = 0;
stream_control(stream, STREAM_CTRL_GET_NUM_TITLES, &guiInfo.Tracks);
if (stream_control(stream, STREAM_CTRL_GET_CURRENT_TITLE, &guiInfo.Track) == STREAM_OK)
guiInfo.Track++;
break;
case STREAMTYPE_DVD:
guiInfo.Tracks = 0;
stream_control(stream, STREAM_CTRL_GET_NUM_TITLES, &guiInfo.Tracks);
guiInfo.Chapters = 0;
stream_control(stream, STREAM_CTRL_GET_NUM_CHAPTERS, &guiInfo.Chapters);
guiInfo.Angles = 0;
stream_control(stream, STREAM_CTRL_GET_NUM_ANGLES, &guiInfo.Angles);
if (stream_control(stream, STREAM_CTRL_GET_CURRENT_TITLE, &guiInfo.Track) == STREAM_OK)
guiInfo.Track++;
// guiInfo.Chapter will be set by mplayer
guiInfo.Angle = 1;
stream_control(stream, STREAM_CTRL_GET_ANGLE, &guiInfo.Angle);
#ifdef CONFIG_DVDREAD
dvd = stream->priv;
guiInfo.AudioStreams = dvd->nr_of_channels;
memcpy(guiInfo.AudioStream, dvd->audio_streams, sizeof(dvd->audio_streams));
guiInfo.Subtitles = dvd->nr_of_subtitles;
memcpy(guiInfo.Subtitle, dvd->subtitles, sizeof(dvd->subtitles));
#endif
break;
case STREAMTYPE_TV:
case STREAMTYPE_DVB:
guiInfo.Tracks = guiInfo.Track = 1;
break;
}
break;
case GUI_SET_VIDEO:
/* video */
guiInfo.sh_video = data;
nfree(guiInfo.CodecName);
if (guiInfo.sh_video)
guiInfo.CodecName = strdup(guiInfo.sh_video->codec->name);
state = (isSeekableStreamtype ? btnReleased : btnDisabled);
btnSet(evForward10sec, state);
btnSet(evBackward10sec, state);
btnSet(evForward1min, state);
btnSet(evBackward1min, state);
btnSet(evForward10min, state);
btnSet(evBackward10min, state);
btnSet(evSetMoviePosition, state);
if (video_driver_list && !gstrcmp(video_driver_list[0], "dxr3") && (((demuxer_t *)mpctx_get_demuxer(guiInfo.mpcontext))->file_format != DEMUXER_TYPE_MPEG_PS) && !gtkVfLAVC) {
gtkMessageBox(MSGBOX_FATAL, MSGTR_GUI_MSG_DXR3NeedsLavc);
return False;
}
break;
case GUI_SET_AUDIO:
sh_audio = data;
if (sh_audio) {
guiInfo.AudioChannels = sh_audio->channels;
guiInfo.AudioPassthrough = (gstrcmp(sh_audio->ad_driver->info->short_name, "hwac3") == 0);
if (!guiInfo.sh_video) {
guiInfo.VideoWindow = False;
guiInfo.VideoWidth = 0;
guiInfo.VideoHeight = 0;
}
} else {
guiInfo.AudioChannels = 0;
guiInfo.AudioPassthrough = False;
}
if (guiInfo.AudioPassthrough)
btnSet(evSetVolume, btnDisabled);
if (guiInfo.AudioChannels < 2 || guiInfo.AudioPassthrough)
btnSet(evSetBalance, btnDisabled);
if (last_balance < 0.0f) {
uiEvent(ivSetVolume, guiInfo.Volume);
if (guiInfo.AudioChannels == 2 && !guiInfo.AudioPassthrough)
uiEvent(ivSetBalance, guiInfo.Balance);
last_balance = guiInfo.Balance;
}
if (gtkEnableAudioEqualizer) {
equalizer_t eq;
unsigned int i, j;
for (i = 0; i < FF_ARRAY_ELEMS(gtkEquChannels); i++) {
for (j = 0; j < FF_ARRAY_ELEMS(*gtkEquChannels); j++) {
eq.channel = i;
eq.band = j;
eq.gain = gtkEquChannels[i][j];
mplayer(MPLAYER_SET_EQUALIZER, 0, &eq);
}
}
}
// These must be done here (in the last call from MPlayer before
// playback starts) and not in GUI_SETUP_VIDEO_WINDOW, because...
// ...without video there will be no call to GUI_SETUP_VIDEO_WINDOW
if (!guiInfo.VideoWindow) {
wsWindowVisibility(&guiApp.videoWindow, wsHideWindow);
btnSet(evFullScreen, gtkLoadFullscreen ? btnPressed : btnReleased);
}
// ...option variable fullscreen determines whether MPlayer will handle
// the window given by WinID as fullscreen window (and will do aspect
// scaling then) or not - quite rubbish
fullscreen = gtkLoadFullscreen;
break;
case GUI_SET_VOLUME_BALANCE:
mixer = data;
mixer_getvolume(mixer, &l, &r);
guiInfo.Volume = FFMAX(l, r);
mixer_getbalance(mixer, &b);
guiInfo.Balance = (b + 1.0) * 50.0; // transform -1..1 to 0..100
if (guiInfo.Balance != last_balance) {
uiEvent(ivSetVolume, guiInfo.Volume);
last_balance = guiInfo.Balance;
}
break;
case GUI_SETUP_VIDEO_WINDOW:
guiInfo.VideoWidth = vo_dwidth;
guiInfo.VideoHeight = vo_dheight;
if (!guiApp.videoWindow.isFullScreen || !guiApp.videoWindow.Mapped) {
if (!guiApp.videoWindow.isFullScreen)
wsWindowResize(&guiApp.videoWindow, guiInfo.VideoWidth, guiInfo.VideoHeight);
if (!guiApp.videoWindow.Mapped)
wsWindowVisibility(&guiApp.videoWindow, wsShowWindow);
}
if (gtkLoadFullscreen ^ guiApp.videoWindow.isFullScreen)
uiEvent(evFullScreen, True);
if (guiWinID >= 0)
wsWindowMove(&guiApp.mainWindow, True, 0, guiInfo.VideoHeight);
wsWindowBackground(&guiApp.videoWindow, -1, -1, -1);
break;
case GUI_HANDLE_X_EVENT:
wsEvent(data);
break;
case GUI_END_PLAY:
guiInfo.sh_video = NULL;
btnSet(evSetVolume, btnReleased);
btnSet(evSetBalance, btnReleased);
uiEvent(ivRedraw, True);
if (guiInfo.Playing) {
if (!guiInfo.PlaylistNext) {
guiInfo.PlaylistNext = True;
break;
}
if (guiInfo.StreamType == STREAMTYPE_CDDA && guiInfo.Track < guiInfo.Tracks) {
uiNext();
break;
}
next = listMgr(PLAYLIST_ITEM_GET_NEXT, 0);
}
if (next) {
uiSetFile(next->path, next->name, STREAMTYPE_FILE);
guiInfo.MediumChanged = GUI_MEDIUM_NEW;
guiInfo.Track = (uintptr_t)listMgr(PLAYLIST_ITEM_GET_POS, next);
} else {
if (guiInfo.MediumChanged == GUI_MEDIUM_NEW)
break;
filename = NULL;
if (isPlaylistStreamtype) {
plItem *curr = listMgr(PLAYLIST_ITEM_GET_CURR, 0);
if (!curr)
uiUnsetFile();
else if ((curr != listMgr(PLAYLIST_GET, 0)) && guiInfo.Playing) {
curr = listMgr(PLAYLIST_ITEM_SET_CURR, listMgr(PLAYLIST_GET, 0));
uiSetFile(curr->path, curr->name, STREAMTYPE_FILE);
guiInfo.Track = 1;
}
} else if (guiInfo.Playing) {
int first = (guiInfo.StreamType == STREAMTYPE_VCD ? 2 : 1);
if (guiInfo.Track != first) {
uiUnsetMedia(True);
guiInfo.Track = first;
}
if (guiInfo.StreamType == STREAMTYPE_DVD) {
guiInfo.Chapter = 1;
guiInfo.Angle = 1;
}
}
guiInfo.ElapsedTime = 0;
guiInfo.Position = 0.0f;
if (gtkShowVideoWindow) {
guiInfo.VideoWindow = True;
if (!guiApp.videoWindow.isFullScreen)
wsWindowResize(&guiApp.videoWindow, guiApp.video.width, guiApp.video.height);
if (!guiApp.videoWindow.Mapped)
wsWindowVisibility(&guiApp.videoWindow, wsShowWindow);
if (gtkLoadFullscreen ^ guiApp.videoWindow.isFullScreen)
uiEvent(evFullScreen, False);
} else {
wsWindowVisibility(&guiApp.videoWindow, wsHideWindow);
guiInfo.VideoWindow = False;
btnSet(evFullScreen, gtkLoadFullscreen ? btnPressed : btnReleased);
}
gui(GUI_SET_STATE, (void *)GUI_STOP);
wsWindowRedraw(&guiApp.videoWindow);
wsMouseVisibility(&guiApp.videoWindow, wsShowMouseCursor);
wsEvents();
}
break;
}
return True;
}
int websSecurityHandler(webs_t wp, char_t *urlPrefix, char_t *webDir, int arg,
char_t *url, char_t *path, char_t *query)
{
char_t *type, *userid, *password, *accessLimit;
int flags, nRet;
accessMeth_t am;
a_assert(websValid(wp));
a_assert(url && *url);
a_assert(path && *path);
/*
* Get the critical request details
*/
type = websGetRequestType(wp);
password = websGetRequestPassword(wp);
userid = websGetRequestUserName(wp);
flags = websGetRequestFlags(wp);
/*
* Get the access limit for the URL. Exit if none found.
*/
accessLimit = umGetAccessLimit(path);
if (accessLimit == NULL) {
return 0;
}
/*
* Check to see if URL must be encrypted
*/
#ifdef WEBS_SSL_SUPPORT
nRet = umGetAccessLimitSecure(accessLimit);
if (nRet && ((flags & WEBS_SECURE) == 0)) {
websStats.access++;
websError(wp, 405, T("Access Denied\nSecure access is required."));
trace(3, T("SEC: Non-secure access attempted on <%s>\n"), path);
/* bugfix 5/24/02 -- we were leaking the memory pointed to by
* 'accessLimit'. Thanks to Simon Byholm.
*/
bfree(B_L, accessLimit);
return 1;
}
#endif
/*
* Get the access limit for the URL
*/
am = umGetAccessMethodForURL(accessLimit);
nRet = 0;
if ((flags & WEBS_LOCAL_REQUEST) && (debugSecurity == 0)) {
/*
* Local access is always allowed (defeat when debugging)
*/
} else if (am == AM_NONE) {
/*
* URL is supposed to be hidden! Make like it wasn't found.
*/
websStats.access++;
websError(wp, 404, T("Page Not Found"));
nRet = 1;
} else if (userid && *userid) {
if (!umUserExists(userid)) {
websStats.access++;
websError(wp, 401, T("Access Denied\nUnknown User"));
trace(3, T("SEC: Unknown user <%s> attempted to access <%s>\n"),
userid, path);
nRet = 1;
} else if (!umUserCanAccessURL(userid, accessLimit)) {
websStats.access++;
websError(wp, 403, T("Access Denied\nProhibited User"));
nRet = 1;
} else if (password && * password) {
char_t * userpass = umGetUserPassword(userid);
if (userpass) {
if (gstrcmp(password, userpass) != 0) {
websStats.access++;
websError(wp, 401, T("Access Denied\nWrong Password"));
trace(3, T("SEC: Password fail for user <%s>")
T("attempt to access <%s>\n"), userid, path);
nRet = 1;
} else {
/*
* User and password check out.
*/
}
bfree (B_L, userpass);
}
#ifdef DIGEST_ACCESS_SUPPORT
} else if (flags & WEBS_AUTH_DIGEST) {
char_t *digestCalc;
/*
* Check digest for equivalence
*/
wp->password = umGetUserPassword(userid);
a_assert(wp->digest);
a_assert(wp->nonce);
a_assert(wp->password);
digestCalc = websCalcDigest(wp);
a_assert(digestCalc);
if (gstrcmp(wp->digest, digestCalc) != 0) {
bfree (B_L, digestCalc);
digestCalc = websCalcUrlDigest(wp);
a_assert(digestCalc);
if (gstrcmp(wp->digest, digestCalc) != 0) {
websStats.access++;
websError(wp, 401, T("Access Denied\nWrong Password"));
nRet = 1;
}
}
bfree (B_L, digestCalc);
#endif
} else {
/*
* No password has been specified
*/
#ifdef DIGEST_ACCESS_SUPPORT
if (am == AM_DIGEST) {
wp->flags |= WEBS_AUTH_DIGEST;
}
#endif
websStats.errors++;
websError(wp, 401,
T("Access to this document requires a password"));
nRet = 1;
}
} else if (am != AM_FULL) {
/*
* This will cause the browser to display a password / username
* dialog
*/
#ifdef DIGEST_ACCESS_SUPPORT
if (am == AM_DIGEST) {
wp->flags |= WEBS_AUTH_DIGEST;
}
#endif
websStats.errors++;
websError(wp, 401, T("Access to this document requires a User ID"));
nRet = 1;
}
bfree(B_L, accessLimit);
return nRet;
}
/* this function gets called by mplayer to update the gui */
int gui(int what, void *data)
{
int idata = (intptr_t) data;
stream_t *stream;
sh_audio_t *sh_audio;
#ifdef CONFIG_DVDREAD
dvd_priv_t *dvdp;
#endif
if(!mygui || !mygui->skin) return FALSE;
if(guiInfo.mpcontext)
{
audio_out = mpctx_get_audio_out(guiInfo.mpcontext);
video_out = mpctx_get_video_out(guiInfo.mpcontext);
mixer = mpctx_get_mixer(guiInfo.mpcontext);
playtree = mpctx_get_playtree_iter(guiInfo.mpcontext);
}
switch (what)
{
case GUI_PREPARE:
{
audio_id = -1;
video_id = -1;
dvdsub_id = -1;
vobsub_id = -1;
stream_cache_size = -1;
autosync = 0;
force_fps = 0;
if(!mygui->playlist->tracks) return FALSE;
switch(guiInfo.StreamType)
{
case STREAMTYPE_FILE:
case STREAMTYPE_STREAM:
uiSetFile(NULL, mygui->playlist->tracks[mygui->playlist->current]->filename, SAME_STREAMTYPE);
guiInfo.Track = mygui->playlist->current + 1;
break;
case STREAMTYPE_DVD:
{
char tmp[512];
#ifdef CONFIG_DVDREAD
dvd_chapter = guiInfo.Chapter;
dvd_angle = guiInfo.Angle;
#endif
sprintf(tmp,"dvd://%d", guiInfo.Track);
uiSetFile(NULL, tmp, SAME_STREAMTYPE);
break;
}
}
guiInfo.VideoWindow = TRUE;
if(gtkAONorm) listRepl(&af_cfg.list, "volnorm", "volnorm");
if(gtkAOExtraStereo)
{
char *name = malloc(12 + 20 + 1);
snprintf(name, 12 + 20, "extrastereo=%f", gtkAOExtraStereoMul);
name[12 + 20] = 0;
listRepl(&af_cfg.list, "extrastereo", name);
free(name);
}
if(gtkCacheOn) stream_cache_size = gtkCacheSize;
if(gtkAutoSyncOn) autosync = gtkAutoSync;
guiInfo.MediumChanged = 0;
break;
}
case GUI_SET_AUDIO:
{
sh_audio = data;
if (sh_audio)
{
guiInfo.AudioChannels = sh_audio->channels;
guiInfo.AudioPassthrough = (gstrcmp(sh_audio->ad_driver->info->short_name, "hwac3") == 0);
if (!guiInfo.sh_video) guiInfo.VideoWindow = FALSE;
}
else
{
guiInfo.AudioChannels = 0;
guiInfo.AudioPassthrough = FALSE;
}
guiSetEvent(evSetVolume);
guiSetEvent(evSetBalance);
if(IsWindowVisible(mygui->videowindow) && !guiInfo.VideoWindow)
ShowWindow(mygui->videowindow, SW_HIDE);
break;
}
case GUI_SET_CONTEXT:
guiInfo.mpcontext = data;
break;
case GUI_SET_VIDEO:
{
guiInfo.sh_video = data;
if (guiInfo.sh_video)
{
codecname = codec_idx2str(guiInfo.sh_video->codec->name_idx);
/* we have video, show the video window */
if(!IsWindowVisible(mygui->videowindow) || IsIconic(mygui->videowindow))
ShowWindow(mygui->videowindow, SW_SHOWNORMAL);
if(WinID == -1)
update_videowindow();
}
break;
}
case GUI_SETUP_VIDEO_WINDOW:
{
guiInfo.VideoWidth = vo_dwidth;
guiInfo.VideoHeight = vo_dheight;
video_aspect = (float)guiInfo.VideoWidth/guiInfo.VideoHeight;
if(WinID != -1)
update_videowindow();
break;
}
case GUI_SET_STREAM:
{
stream = data;
guiInfo.StreamType = stream->type;
switch(guiInfo.StreamType)
{
case STREAMTYPE_DVD:
guiInfo.Tracks = 0;
stream_control(stream, STREAM_CTRL_GET_NUM_TITLES, &guiInfo.Tracks);
guiInfo.Chapters = 0;
stream_control(stream, STREAM_CTRL_GET_NUM_CHAPTERS, &guiInfo.Chapters);
guiInfo.Angles = 0;
stream_control(stream, STREAM_CTRL_GET_NUM_ANGLES, &guiInfo.Angles);
if (stream_control(stream, STREAM_CTRL_GET_CURRENT_TITLE, &guiInfo.Track) == STREAM_OK)
guiInfo.Track++;
// guiInfo.Chapter will be set by mplayer
guiInfo.Angle = 1;
stream_control(stream, STREAM_CTRL_GET_ANGLE, &guiInfo.Angle);
#ifdef CONFIG_DVDREAD
dvdp = stream->priv;
guiInfo.AudioStreams = dvdp->nr_of_channels;
memcpy(guiInfo.AudioStream, dvdp->audio_streams, sizeof(dvdp->audio_streams));
guiInfo.Subtitles = dvdp->nr_of_subtitles;
memcpy(guiInfo.Subtitle, dvdp->subtitles, sizeof(dvdp->subtitles));
#endif
break;
}
break;
}
case GUI_REDRAW:
mygui->updatedisplay(mygui, mygui->mainwindow);
break;
case GUI_SET_STATE:
{
guiInfo.Playing = idata;
switch (guiInfo.Playing)
{
case GUI_PLAY:
{
guiInfo.Playing = GUI_PLAY;
break;
}
case GUI_STOP:
{
guiInfo.Playing = GUI_STOP;
if(movie_aspect >= 0)
movie_aspect = -1;
update_videowindow();
break;
}
case GUI_PAUSE:
guiInfo.Playing = GUI_PAUSE;
break;
}
break;
}
case GUI_RUN_COMMAND:
{
mp_msg(MSGT_GPLAYER,MSGL_V, "cmd: %d\n", idata);
/* MPlayer asks us to quit */
switch(idata)
{
case MP_CMD_VO_FULLSCREEN:
uiFullScreen();
break;
case MP_CMD_QUIT:
{
mygui->uninit(mygui);
nfree(mygui);
exit_player(EXIT_QUIT);
return TRUE;
}
case MP_CMD_PLAY_TREE_STEP:
guiSetEvent(evNext);
break;
case -MP_CMD_PLAY_TREE_STEP:
guiSetEvent(evPrev);
break;
case MP_CMD_STOP:
guiSetEvent(evStop);
break;
default:
break;
}
break;
}
case GUI_RUN_MESSAGE:
break;
case GUI_SET_VOLUME_BALANCE:
{
if(audio_out)
{
/* Some audio_out drivers do not support balance e.g. dsound */
/* FIXME this algo is not correct */
float l, r;
mixer_getvolume(mixer, &l, &r);
guiInfo.Volume = (r > l ? r : l); /* max(r,l) */
if (r != l)
guiInfo.Balance = ((r-l) + 100.0) * 0.5;
else
guiInfo.Balance = 50.0f;
}
break;
}
case GUI_END_PLAY:
{
guiInfo.sh_video = NULL;
if(!guiInfo.PlaylistNext && guiInfo.Playing)
{
guiInfo.PlaylistNext = TRUE;
break;
}
if(guiInfo.PlaylistNext && guiInfo.Playing &&
(mygui->playlist->current < (mygui->playlist->trackcount - 1)) &&
guiInfo.StreamType != STREAMTYPE_DVD &&
guiInfo.StreamType != STREAMTYPE_DVDNAV)
{
/* we've finished this file, reset the aspect */
if(movie_aspect >= 0)
movie_aspect = -1;
guiInfo.PlaylistNext = TRUE;
guiInfo.MediumChanged = GUI_MEDIUM_NEW;
uiSetFile(NULL, mygui->playlist->tracks[(mygui->playlist->current)++]->filename, STREAMTYPE_FILE);
//sprintf(guiInfo.Filename, mygui->playlist->tracks[(mygui->playlist->current)++]->filename);
}
if(guiInfo.MediumChanged == GUI_MEDIUM_NEW)
break;
guiInfo.ElapsedTime = 0;
guiInfo.Position = 0;
guiInfo.AudioChannels = 0;
guiInfo.AudioPassthrough = FALSE;
guiInfo.Track = 1;
guiInfo.Chapter = 1;
guiInfo.Angle = 1;
if (mygui->playlist->current == (mygui->playlist->trackcount - 1))
mygui->playlist->current = 0;
fullscreen = FALSE;
if(style == (WS_VISIBLE | WS_POPUP))
{
style = WS_OVERLAPPEDWINDOW | WS_SIZEBOX;
SetWindowLong(mygui->videowindow, GWL_STYLE, style);
}
gui(GUI_SET_STATE, (void *) GUI_STOP);
break;
}
#ifdef __WINE__
// it's possible to have an X11 video output driver (sending events)
case GUI_HANDLE_X_EVENT:
{
break;
}
#endif
default:
mp_msg(MSGT_GPLAYER, MSGL_ERR, "[GUI] GOT UNHANDLED EVENT %i\n", what);
}
return TRUE;
}
bool_t umUserCanAccessURL(char_t *user, char_t *url)
{
accessMeth_t amURL;
char_t *group, *usergroup, *urlHavingLimit;
short priv;
a_assert(user && *user);
a_assert(url && *url);
/*
* Make sure user exists
*/
if (!umUserExists(user)) {
return FALSE;
}
/*
* Make sure user is enabled
*/
if (!umGetUserEnabled(user)) {
return FALSE;
}
/*
* Make sure user has sufficient privileges (any will do)
*/
usergroup = umGetUserGroup(user);
priv = umGetGroupPrivilege(usergroup);
if (priv == 0) {
return FALSE;
}
/*
* Make sure user's group is enabled
*/
if (!umGetGroupEnabled(usergroup)) {
return FALSE;
}
/*
* The access method of the user group must not be AM_NONE
*/
if (umGetGroupAccessMethod(usergroup) == AM_NONE) {
return FALSE;
}
/*
* Check to see if there is an Access Limit for this URL
*/
urlHavingLimit = umGetAccessLimit(url);
if (urlHavingLimit) {
amURL = umGetAccessLimitMethod(urlHavingLimit);
group = umGetAccessLimitGroup(urlHavingLimit);
bfree(B_L, urlHavingLimit);
} else {
/*
* If there isn't an access limit for the URL, user has full access
*/
return TRUE;
}
/*
* If the access method for the URL is AM_NONE then
* the file "doesn't exist".
*/
if (amURL == AM_NONE) {
return FALSE;
}
/*
* If Access Limit has a group specified, then the user must be a
* member of that group
*/
if (group && *group) {
if (usergroup && (gstrcmp(group, usergroup) != 0)) {
return FALSE;
}
}
/*
* Otherwise, user can access the URL
*/
return TRUE;
}
void * gtkSet( int cmd,float fparam, void * vparam )
{
equalizer_t * eq = (equalizer_t *)vparam;
plItem * item = (plItem *)vparam;
URLItem * url_item = (URLItem *)vparam;
int is_added = True;
switch ( cmd )
{
// --- handle playlist
case gtkAddPlItem: // add item to playlist
if ( plList )
{
plItem * next = plList;
while ( next->next ) { /*printf( "%s\n",next->name );*/ next=next->next; }
next->next=item; item->prev=next;
} else { item->prev=item->next=NULL; plCurrent=plList=item; }
list();
return NULL;
case gtkInsertPlItem: // add item into playlist after current
if ( plCurrent )
{
plItem * curr = plCurrent;
item->next=curr->next;
if (item->next)
item->next->prev=item;
item->prev=curr;
curr->next=item;
plCurrent=plCurrent->next;
return plCurrent;
}
else
return gtkSet(gtkAddPlItem,0,(void*)item);
return NULL;
case gtkGetNextPlItem: // get current item from playlist
if ( plCurrent && plCurrent->next)
{
plCurrent=plCurrent->next;
/*if ( !plCurrent && plList )
{
plItem * next = plList;
while ( next->next ) { if ( !next->next ) break; next=next->next; }
plCurrent=next;
}*/
return plCurrent;
}
return NULL;
case gtkGetPrevPlItem:
if ( plCurrent && plCurrent->prev)
{
plCurrent=plCurrent->prev;
//if ( !plCurrent && plList ) plCurrent=plList;
return plCurrent;
}
return NULL;
case gtkSetCurrPlItem: // set current item
plCurrent=item;
return plCurrent;
case gtkGetCurrPlItem: // get current item
return plCurrent;
case gtkDelCurrPlItem: // delete current item
{
plItem * curr = plCurrent;
if (!curr)
return NULL;
if (curr->prev)
curr->prev->next=curr->next;
if (curr->next)
curr->next->prev=curr->prev;
if (curr==plList)
plList=curr->next;
plCurrent=curr->next;
// Free it
free( curr->path );
free( curr->name );
free( curr );
}
mplCurr(); // Instead of using mplNext && mplPrev
return plCurrent;
case gtkDelPl: // delete list
{
plItem * curr = plList;
plItem * next;
if ( !plList ) return NULL;
if ( !curr->next )
{
free( curr->path );
free( curr->name );
free( curr );
}
else
{
while ( curr->next )
{
next=curr->next;
free( curr->path );
free( curr->name );
free( curr );
curr=next;
}
}
plList=NULL; plCurrent=NULL;
}
return NULL;
// ----- Handle url
case gtkAddURLItem:
if ( URLList )
{
URLItem * next_url = URLList;
is_added = False;
while ( next_url->next )
{
if ( !gstrcmp( next_url->url,url_item->url ) )
{
is_added=True;
break;
}
next_url=next_url->next;
}
if ( ( !is_added )&&( gstrcmp( next_url->url,url_item->url ) ) ) next_url->next=url_item;
} else { url_item->next=NULL; URLList=url_item; }
return NULL;
// --- subtitle
#ifndef CONFIG_FREETYPE
case gtkSetFontFactor:
font_factor=fparam;
guiLoadFont();
return NULL;
#else
case gtkSetFontOutLine:
subtitle_font_thickness=( 8.0f / 100.0f ) * fparam;
guiLoadFont();
return NULL;
case gtkSetFontBlur:
subtitle_font_radius=( 8.0f / 100.0f ) * fparam;
guiLoadFont();
return NULL;
case gtkSetFontTextScale:
text_font_scale_factor=fparam;
guiLoadFont();
return NULL;
case gtkSetFontOSDScale:
osd_font_scale_factor=fparam;
guiLoadFont();
return NULL;
case gtkSetFontEncoding:
gfree( (void **)&subtitle_font_encoding );
subtitle_font_encoding=gstrdup( (char *)vparam );
guiLoadFont();
return NULL;
case gtkSetFontAutoScale:
subtitle_autoscale=(int)fparam;
guiLoadFont();
return NULL;
#endif
#ifdef CONFIG_ICONV
case gtkSetSubEncoding:
gfree( (void **)&sub_cp );
sub_cp=gstrdup( (char *)vparam );
break;
#endif
// --- misc
case gtkClearStruct:
if ( (unsigned int)vparam & guiFilenames )
{
gfree( (void **)&guiIntfStruct.Filename );
gfree( (void **)&guiIntfStruct.Subtitlename );
gfree( (void **)&guiIntfStruct.AudioFile );
gtkSet( gtkDelPl,0,NULL );
}
#ifdef CONFIG_DVDREAD
if ( (unsigned int)vparam & guiDVD ) memset( &guiIntfStruct.DVD,0,sizeof( guiDVDStruct ) );
#endif
#ifdef CONFIG_VCD
if ( (unsigned int)vparam & guiVCD ) guiIntfStruct.VCDTracks=0;
#endif
return NULL;
case gtkSetExtraStereo:
gtkAOExtraStereoMul=fparam;
if (guiIntfStruct.afilter)
af_control_any_rev(guiIntfStruct.afilter,
AF_CONTROL_ES_MUL | AF_CONTROL_SET, >kAOExtraStereoMul);
return NULL;
case gtkSetPanscan:
{
mp_cmd_t * mp_cmd;
mp_cmd=calloc( 1,sizeof( *mp_cmd ) );
mp_cmd->id=MP_CMD_PANSCAN; mp_cmd->name=strdup( "panscan" );
mp_cmd->args[0].v.f=fparam; mp_cmd->args[1].v.i=1;
mp_input_queue_cmd( mp_cmd );
}
return NULL;
case gtkSetAutoq:
auto_quality=(int)fparam;
return NULL;
// --- set equalizers
case gtkSetContrast:
if ( guiIntfStruct.sh_video ) set_video_colors( guiIntfStruct.sh_video,"contrast",(int)fparam );
return NULL;
case gtkSetBrightness:
if ( guiIntfStruct.sh_video ) set_video_colors( guiIntfStruct.sh_video,"brightness",(int)fparam );
return NULL;
case gtkSetHue:
if ( guiIntfStruct.sh_video ) set_video_colors( guiIntfStruct.sh_video,"hue",(int)fparam );
return NULL;
case gtkSetSaturation:
if ( guiIntfStruct.sh_video ) set_video_colors( guiIntfStruct.sh_video,"saturation",(int)fparam );
return NULL;
case gtkSetEqualizer:
{
af_control_ext_t tmp;
if ( eq )
{
gtkEquChannels[eq->channel][eq->band]=eq->gain;
tmp.ch = eq->channel;
tmp.arg = gtkEquChannels[eq->channel];
if (guiIntfStruct.afilter)
af_control_any_rev(guiIntfStruct.afilter,
AF_CONTROL_EQUALIZER_GAIN | AF_CONTROL_SET, &tmp);
}
else
{
int i;
memset( gtkEquChannels,0,sizeof( gtkEquChannels ) );
if (guiIntfStruct.afilter)
for ( i=0;i<6;i++ )
{
tmp.ch = i;
tmp.arg = gtkEquChannels[i];
af_control_any_rev(guiIntfStruct.afilter,
AF_CONTROL_EQUALIZER_GAIN | AF_CONTROL_SET, &tmp);
}
}
return NULL;
}
}
return NULL;
}
int guiGetEvent( int type,void * arg )
{
const ao_functions_t *audio_out = NULL;
const vo_functions_t *video_out = NULL;
mixer_t *mixer = NULL;
stream_t * stream = arg;
#ifdef CONFIG_DVDREAD
dvd_priv_t * dvdp = arg;
#endif
if (guiIntfStruct.mpcontext) {
audio_out = mpctx_get_audio_out(guiIntfStruct.mpcontext);
video_out = mpctx_get_video_out(guiIntfStruct.mpcontext);
mixer = mpctx_get_mixer(guiIntfStruct.mpcontext);
}
switch ( type )
{
case guiXEvent:
guiIntfStruct.event_struct=arg;
wsEvents( wsDisplay,arg,NULL );
gtkEventHandling();
break;
case guiCEvent:
switch ( (int)arg )
{
case guiSetPlay:
guiIntfStruct.Playing=1;
// if ( !gtkShowVideoWindow ) wsVisibleWindow( &appMPlayer.subWindow,wsHideWindow );
break;
case guiSetStop:
guiIntfStruct.Playing=0;
// if ( !gtkShowVideoWindow ) wsVisibleWindow( &appMPlayer.subWindow,wsHideWindow );
break;
case guiSetPause: guiIntfStruct.Playing=2; break;
}
mplState();
break;
case guiSetState:
mplState();
break;
case guiSetFileName:
if ( arg ) guiSetFilename( guiIntfStruct.Filename,arg );
break;
case guiSetAudioOnly:
guiIntfStruct.AudioOnly=(int)arg;
if ( (int)arg ) { guiIntfStruct.NoWindow=True; wsVisibleWindow( &appMPlayer.subWindow,wsHideWindow ); }
else wsVisibleWindow( &appMPlayer.subWindow,wsShowWindow );
break;
case guiSetContext:
guiIntfStruct.mpcontext=arg;
case guiSetDemuxer:
guiIntfStruct.demuxer=arg;
break;
case guiSetAfilter:
guiIntfStruct.afilter=arg;
break;
case guiSetShVideo:
{
if ( !appMPlayer.subWindow.isFullScreen )
{
wsResizeWindow( &appMPlayer.subWindow,vo_dwidth,vo_dheight );
wsMoveWindow( &appMPlayer.subWindow,True,appMPlayer.sub.x,appMPlayer.sub.y );
}
guiIntfStruct.MovieWidth=vo_dwidth;
guiIntfStruct.MovieHeight=vo_dheight;
if (guiWinID>=0)
wsMoveWindow( &appMPlayer.mainWindow,0,0, vo_dheight);
WinID = appMPlayer.subWindow.WindowID;
}
break;
#ifdef CONFIG_DVDREAD
case guiSetDVD:
guiIntfStruct.DVD.titles=dvdp->vmg_file->tt_srpt->nr_of_srpts;
guiIntfStruct.DVD.chapters=dvdp->vmg_file->tt_srpt->title[dvd_title].nr_of_ptts;
guiIntfStruct.DVD.angles=dvdp->vmg_file->tt_srpt->title[dvd_title].nr_of_angles;
guiIntfStruct.DVD.nr_of_audio_channels=dvdp->nr_of_channels;
memcpy( guiIntfStruct.DVD.audio_streams,dvdp->audio_streams,sizeof( dvdp->audio_streams ) );
guiIntfStruct.DVD.nr_of_subtitles=dvdp->nr_of_subtitles;
memcpy( guiIntfStruct.DVD.subtitles,dvdp->subtitles,sizeof( dvdp->subtitles ) );
guiIntfStruct.DVD.current_title=dvd_title + 1;
guiIntfStruct.DVD.current_chapter=dvd_chapter + 1;
guiIntfStruct.DVD.current_angle=dvd_angle + 1;
guiIntfStruct.Track=dvd_title + 1;
break;
#endif
case guiSetStream:
guiIntfStruct.StreamType=stream->type;
switch( stream->type )
{
#ifdef CONFIG_DVDREAD
case STREAMTYPE_DVD:
guiGetEvent( guiSetDVD,(char *)stream->priv );
break;
#endif
#ifdef CONFIG_VCD
case STREAMTYPE_VCD:
{
int i;
if (!stream->priv)
{
guiIntfStruct.VCDTracks=0;
break;
}
for ( i=1;i < 100;i++ )
if ( vcd_seek_to_track( stream->priv,i ) < 0 ) break;
vcd_seek_to_track( stream->priv,vcd_track );
guiIntfStruct.VCDTracks=--i;
break;
}
#endif
default: break;
}
break;
case guiIEvent:
mp_msg( MSGT_GPLAYER,MSGL_V,"cmd: %d\n",(int)arg );
switch( (int)arg )
{
case MP_CMD_QUIT:
mplEventHandling( evExit,0 );
break;
case MP_CMD_VO_FULLSCREEN:
mplEventHandling( evFullScreen,0 );
break;
}
break;
case guiReDraw:
mplEventHandling( evRedraw,0 );
break;
case guiSetVolume:
if ( audio_out )
{
float l,r;
mixer_getvolume( mixer,&l,&r );
guiIntfStruct.Volume=(r>l?r:l);
if ( r != l ) guiIntfStruct.Balance=( ( r - l ) + 100 ) * 0.5f;
else guiIntfStruct.Balance=50.0f;
btnModify( evSetVolume,guiIntfStruct.Volume );
btnModify( evSetBalance,guiIntfStruct.Balance );
}
break;
case guiSetFileFormat:
guiIntfStruct.FileFormat=(int)arg;
break;
case guiSetValues:
// -- video
guiIntfStruct.sh_video=arg;
if ( arg )
{
sh_video_t * sh = arg;
guiIntfStruct.FPS=sh->fps;
}
if ( guiIntfStruct.NoWindow ) wsVisibleWindow( &appMPlayer.subWindow,wsHideWindow );
if ( guiIntfStruct.StreamType == STREAMTYPE_STREAM ) btnSet( evSetMoviePosition,btnDisabled );
else btnSet( evSetMoviePosition,btnReleased );
// -- audio
if ( audio_out )
{
float l,r;
mixer_getvolume( mixer,&l,&r );
guiIntfStruct.Volume=(r>l?r:l);
if ( r != l ) guiIntfStruct.Balance=( ( r - l ) + 100 ) * 0.5f;
else guiIntfStruct.Balance=50.0f;
btnModify( evSetVolume,guiIntfStruct.Volume );
btnModify( evSetBalance,guiIntfStruct.Balance );
}
if ( gtkEnableAudioEqualizer )
{
equalizer_t eq;
int i,j;
for ( i=0;i<6;i++ )
for ( j=0;j<10;j++ )
{
eq.channel=i; eq.band=j; eq.gain=gtkEquChannels[i][j];
gtkSet( gtkSetEqualizer,0,&eq );
}
}
// -- subtitle
#ifdef CONFIG_DXR3
if ( video_driver_list && !gstrcmp( video_driver_list[0],"dxr3" ) && guiIntfStruct.FileFormat != DEMUXER_TYPE_MPEG_PS && !gtkVfLAVC )
{
gtkMessageBox( GTK_MB_FATAL,MSGTR_NEEDLAVC );
guiIntfStruct.Playing=0;
return True;
}
#endif
break;
case guiSetDefaults:
// if ( guiIntfStruct.Playing == 1 && guiIntfStruct.FilenameChanged )
if ( guiIntfStruct.FilenameChanged )
{
audio_id=-1;
video_id=-1;
dvdsub_id=-1;
vobsub_id=-1;
stream_cache_size=-1;
autosync=0;
vcd_track=0;
dvd_title=0;
force_fps=0;
}
guiIntfStruct.demuxer=NULL;
guiIntfStruct.sh_video=NULL;
wsPostRedisplay( &appMPlayer.subWindow );
break;
case guiSetParameters:
guiGetEvent( guiSetDefaults,NULL );
switch ( guiIntfStruct.StreamType )
{
case STREAMTYPE_PLAYLIST:
break;
#ifdef CONFIG_VCD
case STREAMTYPE_VCD:
{
char tmp[512];
sprintf( tmp,"vcd://%d",guiIntfStruct.Track + 1 );
guiSetFilename( guiIntfStruct.Filename,tmp );
}
break;
#endif
#ifdef CONFIG_DVDREAD
case STREAMTYPE_DVD:
{
char tmp[512];
sprintf( tmp,"dvd://%d",guiIntfStruct.Title );
guiSetFilename( guiIntfStruct.Filename,tmp );
}
dvd_chapter=guiIntfStruct.Chapter;
dvd_angle=guiIntfStruct.Angle;
break;
#endif
}
//if ( guiIntfStruct.StreamType != STREAMTYPE_PLAYLIST ) // Does not make problems anymore!
{
if ( guiIntfStruct.Filename ) filename=gstrdup( guiIntfStruct.Filename );
else if ( filename ) guiSetFilename( guiIntfStruct.Filename,filename );
}
// --- video opts
if ( !video_driver_list )
{
int i = 0;
while ( video_out_drivers[i++] )
if ( video_out_drivers[i - 1]->control( VOCTRL_GUISUPPORT,NULL ) == VO_TRUE )
{
gaddlist( &video_driver_list,(char *)video_out_drivers[i - 1]->info->short_name );
break;
}
}
if ( !video_driver_list && !video_driver_list[0] ) { gtkMessageBox( GTK_MB_FATAL,MSGTR_IDFGCVD ); exit_player(EXIT_ERROR); }
{
int i = 0;
guiIntfStruct.NoWindow=False;
while ( video_out_drivers[i++] )
if ( video_out_drivers[i - 1]->control( VOCTRL_GUISUPPORT,NULL ) == VO_TRUE )
{
if ( ( video_driver_list && !gstrcmp( video_driver_list[0],(char *)video_out_drivers[i - 1]->info->short_name ) )&&( video_out_drivers[i - 1]->control( VOCTRL_GUI_NOWINDOW,NULL ) == VO_TRUE ) )
{ guiIntfStruct.NoWindow=True; break; }
}
}
#ifdef CONFIG_DXR3
remove_vf( "lavc" );
if ( video_driver_list && !gstrcmp( video_driver_list[0],"dxr3" ) )
{
if ( ( guiIntfStruct.StreamType != STREAMTYPE_DVD)&&( guiIntfStruct.StreamType != STREAMTYPE_VCD ) )
{
if ( gtkVfLAVC ) add_vf( "lavc" );
}
}
#endif
// ---
if ( gtkVfPP ) add_vf( "pp" );
else remove_vf( "pp" );
// --- audio opts
// if ( ao_plugin_cfg.plugin_list ) { free( ao_plugin_cfg.plugin_list ); ao_plugin_cfg.plugin_list=NULL; }
if (gtkAONorm)
greplace(&af_cfg.list, "volnorm", "volnorm");
if (gtkEnableAudioEqualizer)
greplace(&af_cfg.list, "equalizer", "equalizer");
if ( gtkAOExtraStereo )
{
char *name = malloc(12 + 20 + 1);
snprintf(name, 12 + 20, "extrastereo=%f", gtkAOExtraStereoMul);
name[12 + 20] = 0;
greplace(&af_cfg.list, "extrastereo", name);
free(name);
}
#ifdef CONFIG_OSS_AUDIO
if ( audio_driver_list && !gstrncmp( audio_driver_list[0],"oss",3 ) )
{
char *tmp;
mixer_device = gtkAOOSSMixer;
mixer_channel = gtkAOOSSMixerChannel;
if (gtkAOOSSDevice) {
tmp = calloc( 1,strlen( gtkAOOSSDevice ) + 7 );
sprintf( tmp,"oss:%s",gtkAOOSSDevice );
} else
tmp = strdup("oss");
gaddlist( &audio_driver_list,tmp );
free(tmp);
}
#endif
#ifdef CONFIG_ALSA
if ( audio_driver_list && !gstrncmp( audio_driver_list[0],"alsa",4 ) )
{
char *tmp;
mixer_device = gtkAOALSAMixer;
mixer_channel = gtkAOALSAMixerChannel;
if (gtkAOALSADevice) {
tmp = calloc( 1,strlen( gtkAOALSADevice ) + 14 );
sprintf( tmp,"alsa:device=%s",gtkAOALSADevice );
} else
tmp = strdup("alsa");
gaddlist( &audio_driver_list,tmp );
free(tmp);
}
#endif
#ifdef CONFIG_SDL
if ( audio_driver_list && !gstrncmp( audio_driver_list[0],"sdl",3 ) )
{
char *tmp;
if (gtkAOSDLDriver) {
tmp = calloc( 1,strlen( gtkAOSDLDriver ) + 10 );
sprintf( tmp,"sdl:%s",gtkAOSDLDriver );
} else
tmp = strdup("sdl");
gaddlist( &audio_driver_list,tmp );
free(tmp);
}
#endif
#ifdef CONFIG_ESD
if ( audio_driver_list && !gstrncmp( audio_driver_list[0],"esd",3 ) )
{
char *tmp;
if (gtkAOESDDevice) {
tmp = calloc( 1,strlen( gtkAOESDDevice ) + 10 );
sprintf( tmp,"esd:%s",gtkAOESDDevice );
} else
tmp = strdup("esd");
gaddlist( &audio_driver_list,tmp );
free(tmp);
}
#endif
// -- subtitle
//subdata->filename=gstrdup( guiIntfStruct.Subtitlename );
stream_dump_type=0;
if ( gtkSubDumpMPSub ) stream_dump_type=4;
if ( gtkSubDumpSrt ) stream_dump_type=6;
gtkSubDumpMPSub=gtkSubDumpSrt=0;
guiLoadFont();
// --- misc
if ( gtkCacheOn ) stream_cache_size=gtkCacheSize;
if ( gtkAutoSyncOn ) autosync=gtkAutoSync;
if ( guiIntfStruct.AudioFile ) audio_stream=gstrdup( guiIntfStruct.AudioFile );
else if ( guiIntfStruct.FilenameChanged ) gfree( (void**)&audio_stream );
//audio_stream=NULL;
guiIntfStruct.DiskChanged=0;
guiIntfStruct.FilenameChanged=0;
guiIntfStruct.NewPlay=0;
#ifdef CONFIG_ASS
ass_enabled = gtkASS.enabled;
ass_use_margins = gtkASS.use_margins;
ass_top_margin = gtkASS.top_margin;
ass_bottom_margin = gtkASS.bottom_margin;
#endif
break;
}
return False;
}
bool_t umUserCanAccessURL(char_t *user, char_t *url)
{
accessMeth_t amURL;
char_t *group, *usergroup, *urlHavingLimit;
short priv;
a_assert(user && *user);
a_assert(url && *url);
/*
* Make sure user exists
*/
if (!umUserExists(user)) {
return FALSE;
}
/*
* Make sure user is enabled
*/
if (!umGetUserEnabled(user)) {
return FALSE;
}
/*
* Make sure user has sufficient privileges (any will do)
*/
usergroup = umGetUserGroup(user);
priv = umGetGroupPrivilege(usergroup);
if (priv == 0) {
return FALSE;
}
/*
* Make sure user's group is enabled
*/
if (!umGetGroupEnabled(usergroup)) {
return FALSE;
}
/*
* The access method of the user group must not be AM_NONE
*/
if (umGetGroupAccessMethod(usergroup) == AM_NONE) {
return FALSE;
}
/*
* Check to see if there is an Access Limit for this URL
*/
urlHavingLimit = umGetAccessLimit(url);
if (urlHavingLimit) {
amURL = umGetAccessLimitMethod(urlHavingLimit);
group = umGetAccessLimitGroup(urlHavingLimit);
bfree(B_L, urlHavingLimit);
} else {
/*
* If there isn't an access limit for the URL, user has full access
*/
return TRUE;
}
/*
* If the access method for the URL is AM_NONE then
* the file "doesn't exist".
*/
if (amURL == AM_NONE) {
return FALSE;
}
/*
* If Access Limit has a group specified, then the user must be a
* member of that group
*/
if (group && *group) {
#ifdef qHierarchicalAccess
/*
* If we are compiling with the hierarchical access extensions, we
* instead call the user-provided function that checks to see whether
* the current user's access level is greater than or equal to the
* access level required for this URL.
*/
return dmfCanAccess(usergroup, group);
#else
if (usergroup && (gstrcmp(group, usergroup) != 0)) {
return FALSE;
}
#endif
}
/*
* Otherwise, user can access the URL
*/
return TRUE;
}
static int getLexicalToken(ej_t* ep, int state)
{
ringq_t *inq, *tokq;
ejinput_t* ip;
int done, tid, c, quote, style;
a_assert(ep);
ip = ep->input;
a_assert(ip);
inq = &ip->script;
tokq = &ip->tokbuf;
ep->tid = -1;
tid = -1;
ep->token = T("");
ringqFlush(tokq);
if (ip->putBackTokenId > 0) {
ringqPutStr(tokq, ip->putBackToken);
tid = ip->putBackTokenId;
ip->putBackTokenId = 0;
ep->token = (char_t*) tokq->servp;
return tid;
}
if ((c = inputGetc(ep)) < 0) {
return TOK_EOF;
}
for (done = 0; !done; ) {
switch (c) {
case -1:
return TOK_EOF;
case ' ':
case '\t':
case '\r':
do {
if ((c = inputGetc(ep)) < 0)
break;
} while (c == ' ' || c == '\t' || c == '\r');
break;
case '\n':
return TOK_NEWLINE;
case '(':
tokenAddChar(ep, c);
return TOK_LPAREN;
case ')':
tokenAddChar(ep, c);
return TOK_RPAREN;
case '{':
tokenAddChar(ep, c);
return TOK_LBRACE;
case '}':
tokenAddChar(ep, c);
return TOK_RBRACE;
case '+':
if ((c = inputGetc(ep)) < 0) {
ejError(ep, T("Syntax Error"));
return TOK_ERR;
}
if (c != '+' ) {
inputPutback(ep, c);
tokenAddChar(ep, EXPR_PLUS);
return TOK_EXPR;
}
tokenAddChar(ep, EXPR_INC);
return TOK_INC_DEC;
case '-':
if ((c = inputGetc(ep)) < 0) {
ejError(ep, T("Syntax Error"));
return TOK_ERR;
}
if (c != '-' ) {
inputPutback(ep, c);
tokenAddChar(ep, EXPR_MINUS);
return TOK_EXPR;
}
tokenAddChar(ep, EXPR_DEC);
return TOK_INC_DEC;
case '*':
tokenAddChar(ep, EXPR_MUL);
return TOK_EXPR;
case '%':
tokenAddChar(ep, EXPR_MOD);
return TOK_EXPR;
case '/':
/*
* Handle the division operator and comments
*/
if ((c = inputGetc(ep)) < 0) {
ejError(ep, T("Syntax Error"));
return TOK_ERR;
}
if (c != '*' && c != '/') {
inputPutback(ep, c);
tokenAddChar(ep, EXPR_DIV);
return TOK_EXPR;
}
style = c;
/*
* Eat comments. Both C and C++ comment styles are supported.
*/
while (1) {
if ((c = inputGetc(ep)) < 0) {
ejError(ep, T("Syntax Error"));
return TOK_ERR;
}
if (c == '\n' && style == '/') {
break;
} else if (c == '*') {
c = inputGetc(ep);
if (style == '/') {
if (c == '\n') {
break;
}
} else {
if (c == '/') {
break;
}
}
}
}
/*
* Continue looking for a token, so get the next character
*/
if ((c = inputGetc(ep)) < 0) {
return TOK_EOF;
}
break;
case '<': /* < and <= */
if ((c = inputGetc(ep)) < 0) {
ejError(ep, T("Syntax Error"));
return TOK_ERR;
}
if (c == '<') {
tokenAddChar(ep, EXPR_LSHIFT);
return TOK_EXPR;
} else if (c == '=') {
tokenAddChar(ep, EXPR_LESSEQ);
return TOK_EXPR;
}
tokenAddChar(ep, EXPR_LESS);
inputPutback(ep, c);
return TOK_EXPR;
case '>': /* > and >= */
if ((c = inputGetc(ep)) < 0) {
ejError(ep, T("Syntax Error"));
return TOK_ERR;
}
if (c == '>') {
tokenAddChar(ep, EXPR_RSHIFT);
return TOK_EXPR;
} else if (c == '=') {
tokenAddChar(ep, EXPR_GREATEREQ);
return TOK_EXPR;
}
tokenAddChar(ep, EXPR_GREATER);
inputPutback(ep, c);
return TOK_EXPR;
case '=': /* "==" */
if ((c = inputGetc(ep)) < 0) {
ejError(ep, T("Syntax Error"));
return TOK_ERR;
}
if (c == '=') {
tokenAddChar(ep, EXPR_EQ);
return TOK_EXPR;
}
inputPutback(ep, c);
return TOK_ASSIGNMENT;
case '!': /* "!=" or "!"*/
if ((c = inputGetc(ep)) < 0) {
ejError(ep, T("Syntax Error"));
return TOK_ERR;
}
if (c == '=') {
tokenAddChar(ep, EXPR_NOTEQ);
return TOK_EXPR;
}
inputPutback(ep, c);
tokenAddChar(ep, EXPR_BOOL_COMP);
return TOK_EXPR;
case ';':
tokenAddChar(ep, c);
return TOK_SEMI;
case ',':
tokenAddChar(ep, c);
return TOK_COMMA;
case '|': /* "||" */
if ((c = inputGetc(ep)) < 0 || c != '|') {
ejError(ep, T("Syntax Error"));
return TOK_ERR;
}
tokenAddChar(ep, COND_OR);
return TOK_LOGICAL;
case '&': /* "&&" */
if ((c = inputGetc(ep)) < 0 || c != '&') {
ejError(ep, T("Syntax Error"));
return TOK_ERR;
}
tokenAddChar(ep, COND_AND);
return TOK_LOGICAL;
case '\"': /* String quote */
case '\'':
quote = c;
if ((c = inputGetc(ep)) < 0) {
ejError(ep, T("Syntax Error"));
return TOK_ERR;
}
while (c != quote) {
/*
* check for escape sequence characters
*/
if (c == '\\') {
c = inputGetc(ep);
if (gisdigit(c)) {
/*
* octal support, \101 maps to 65 = 'A'. put first char
* back so converter will work properly.
*/
inputPutback(ep, c);
c = charConvert(ep, OCTAL, 3);
} else {
switch (c) {
case 'n':
c = '\n';
break;
case 'b':
c = '\b';
break;
case 'f':
c = '\f';
break;
case 'r':
c = '\r';
break;
case 't':
c = '\t';
break;
case 'x':
/*
* hex support, \x41 maps to 65 = 'A'
*/
c = charConvert(ep, HEX, 2);
break;
case 'u':
/*
* unicode support, \x0401 maps to 65 = 'A'
*/
c = charConvert(ep, HEX, 2);
c = c*16 + charConvert(ep, HEX, 2);
break;
case '\'':
case '\"':
case '\\':
break;
default:
ejError(ep, T("Invalid Escape Sequence"));
return TOK_ERR;
}
}
if (tokenAddChar(ep, c) < 0) {
return TOK_ERR;
}
} else {
if (tokenAddChar(ep, c) < 0) {
return TOK_ERR;
}
}
if ((c = inputGetc(ep)) < 0) {
ejError(ep, T("Unmatched Quote"));
return TOK_ERR;
}
}
return TOK_LITERAL;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
do {
if (tokenAddChar(ep, c) < 0) {
return TOK_ERR;
}
if ((c = inputGetc(ep)) < 0)
break;
} while (gisdigit(c));
inputPutback(ep, c);
return TOK_LITERAL;
default:
/*
* Identifiers or a function names
*/
while (1) {
if (c == '\\') {
/*
* just ignore any \ characters.
*/
} else if (tokenAddChar(ep, c) < 0) {
break;
}
if ((c = inputGetc(ep)) < 0) {
break;
}
if (!gisalnum(c) && c != '$' && c != '_' &&
c != '\\') {
break;
}
}
if (! gisalpha(*tokq->servp) && *tokq->servp != '$' &&
*tokq->servp != '_') {
ejError(ep, T("Invalid identifier %s"), tokq->servp);
return TOK_ERR;
}
/*
* Check for reserved words (only "if", "else", "var", "for"
* and "return" at the moment)
*/
if (state == STATE_STMT) {
if (gstrcmp(ep->token, T("if")) == 0) {
return TOK_IF;
} else if (gstrcmp(ep->token, T("else")) == 0) {
return TOK_ELSE;
} else if (gstrcmp(ep->token, T("var")) == 0) {
return TOK_VAR;
} else if (gstrcmp(ep->token, T("for")) == 0) {
return TOK_FOR;
} else if (gstrcmp(ep->token, T("return")) == 0) {
if ((c == ';') || (c == '(')) {
inputPutback(ep, c);
}
return TOK_RETURN;
}
}
/*
* Skip white space after token to find out whether this is
* a function or not.
*/
while (c == ' ' || c == '\t' || c == '\r' || c == '\n') {
if ((c = inputGetc(ep)) < 0)
break;
}
tid = (c == '(') ? TOK_FUNCTION : TOK_ID;
done++;
}
}
/*
* Putback the last extra character for next time
*/
inputPutback(ep, c);
return tid;
}
sym_t *symEnter(sym_fd_t sd, char_t *name, value_t v, int arg)
{
sym_tabent_t *tp;
sym_t *sp, *last;
char_t *cp;
int hindex;
a_assert(name);
a_assert(0 <= sd && sd < symMax);
tp = sym[sd];
a_assert(tp);
/*
* Calculate the first daisy-chain from the hash table. If non-zero, then
* we have daisy-chain, so scan it and look for the symbol.
*/
last = NULL;
hindex = hashIndex(tp, name);
if ((sp = tp->hash_table[hindex]) != NULL) {
for (; sp; sp = sp->forw) {
cp = sp->name.value.string;
if (cp[0] == name[0] && gstrcmp(cp, name) == 0) {
break;
}
last = sp;
}
if (sp) {
/*
* Found, so update the value
* If the caller stores handles which require freeing, they
* will be lost here. It is the callers responsibility to free
* resources before overwriting existing contents. We will here
* free allocated strings which occur due to value_instring().
* We should consider providing the cleanup function on the open rather
* than the close and then we could call it here and solve the problem.
*/
if (sp->content.valid) {
valueFree(&sp->content);
}
sp->content = v;
sp->arg = arg;
return sp;
}
/*
* Not found so allocate and append to the daisy-chain
*/
sp = (sym_t*) balloc(B_L, sizeof(sym_t));
if (sp == NULL) {
return NULL;
}
sp->name = valueString(name, VALUE_ALLOCATE);
sp->content = v;
sp->forw = (sym_t*) NULL;
sp->arg = arg;
last->forw = sp;
} else {
/*
* Daisy chain is empty so we need to start the chain
*/
sp = (sym_t*) balloc(B_L, sizeof(sym_t));
if (sp == NULL) {
return NULL;
}
tp->hash_table[hindex] = sp;
tp->hash_table[hashIndex(tp, name)] = sp;
sp->forw = (sym_t*) NULL;
sp->content = v;
sp->arg = arg;
sp->name = valueString(name, VALUE_ALLOCATE);
}
return sp;
}
int dbLoad(int did, char_t *filename, int flags)
{
gstat_t sbuf;
char_t *buf, *keyword, *value, *path, *ptr;
char_t *tablename;
int fd, tid, row;
dbTable_t *pTable;
a_assert(did >= 0);
fmtAlloc(&path, FNAMESIZE, T("%s/%s"), basicGetProductDir(), filename);
trace(4, T("DB: About to read data file <%s>\n"), path);
if (gstat(path, &sbuf) < 0) {
trace(3, T("DB: Failed to stat persistent data file.\n"));
bfree(B_L, path);
return -1;
}
fd = gopen(path, O_RDONLY | O_BINARY, 0666);
bfree(B_L, path);
if (fd < 0) {
trace(3, T("DB: No persistent data file present.\n"));
return -1;
}
if (sbuf.st_size <= 0) {
trace(3, T("DB: Persistent data file is empty.\n"));
gclose(fd);
return -1;
}
/*
* Read entire file into temporary buffer
*/
buf = balloc(B_L, sbuf.st_size + 1);
#ifdef CE
if (readAscToUni(fd, &buf, sbuf.st_size) != (int)sbuf.st_size) {
#else
if (gread(fd, buf, sbuf.st_size) != (int)sbuf.st_size) {
#endif
trace(3, T("DB: Persistent data read failed.\n"));
bfree(B_L, buf);
gclose(fd);
return -1;
}
gclose(fd);
*(buf + sbuf.st_size) = '\0';
row = -1;
tid = -1;
pTable = NULL;
ptr = gstrtok(buf, T("\n"));
tablename = NULL;
do {
if (crack(ptr, &keyword, &value) < 0) {
trace(5, T("DB: Failed to crack line %s\n"), ptr);
continue;
}
a_assert(keyword && *keyword);
if (gstrcmp(keyword, KEYWORD_TABLE) == 0) {
/*
* Table name found, check to see if it's registered
*/
if (tablename) {
bfree(B_L, tablename);
}
tablename = bstrdup(B_L, value);
tid = dbGetTableId(did, tablename);
if (tid >= 0) {
pTable = dbListTables[tid];
} else {
pTable = NULL;
}
} else if (gstrcmp(keyword, KEYWORD_ROW) == 0) {
/*
* Row/Record indicator found, add a new row to table
*/
if (tid >= 0) {
int nRows = dbGetTableNrow(did, tablename);
if (dbSetTableNrow(did, tablename, nRows + 1) == 0) {
row = nRows;
}
}
} else if (row != -1) {
/*
* some other data found, assume it's a COLUMN=value
*/
int nColumn = GetColumnIndex(tid, keyword);
if ((nColumn >= 0) && (pTable != NULL)) {
int nColumnType = pTable->columnTypes[nColumn];
if (nColumnType == T_STRING) {
dbWriteStr(did, tablename, keyword, row, value);
} else {
dbWriteInt(did, tablename, keyword, row, gstrtoi(value));
}
}
}
} while ((ptr = gstrtok(NULL, T("\n"))) != NULL);
if (tablename) {
bfree(B_L, tablename);
}
bfree(B_L, buf);
return 0;
}
/******************************************************************************/
/*
* Return a table id given the table name
*/
int dbGetTableId(int did, char_t *tablename)
{
int tid;
dbTable_t *pTable;
a_assert(tablename);
for (tid = 0; (tid < dbMaxTables); tid++) {
if ((pTable = dbListTables[tid]) != NULL) {
if (gstrcmp(tablename, pTable->name) == 0) {
return tid;
}
}
}
return -1;
}
static void formAddGroup(webs_t wp, char_t *path, char_t *query)
{
char_t *group, *enabled, *privilege, *method, *ok, *pChar;
int nCheck;
short priv;
accessMeth_t am;
bool_t bDisable;
a_assert(wp);
group = websGetVar(wp, T("group"), T(""));
method = websGetVar(wp, T("method"), T(""));
enabled = websGetVar(wp, T("enabled"), T(""));
privilege = websGetVar(wp, T("privilege"), T(""));
ok = websGetVar(wp, T("ok"), T(""));
websHeader(wp);
websMsgStart(wp);
if (gstricmp(ok, T("ok")) != 0) {
websWrite(wp, T("Add Group Cancelled."));
} else if ((group == NULL) || (*group == 0)) {
websWrite(wp, T("No Group Name was entered."));
} else if (umGroupExists(group)) {
websWrite(wp, T("ERROR: Group, \"%s\" already exists."), group);
} else {
if (privilege && *privilege) {
/*
* privilege is a mulitple <SELECT> var, and must be parsed.
* Values for these variables are space delimited.
*/
priv = 0;
for (pChar = privilege; *pChar; pChar++) {
if (*pChar == ' ') {
*pChar = '\0';
priv |= gatoi(privilege);
*pChar = ' ';
privilege = pChar + 1;
}
}
priv |= gatoi(privilege);
} else {
priv = 0;
}
if (method && *method) {
am = (accessMeth_t) gatoi(method);
} else {
am = AM_FULL;
}
if (enabled && *enabled && (gstrcmp(enabled, T("on")) == 0)) {
bDisable = FALSE;
} else {
bDisable = TRUE;
}
nCheck = umAddGroup(group, priv, am, 0, bDisable);
if (nCheck != 0) {
websWrite(wp, T("Unable to add group, \"%s\", code: %d "),
group, nCheck);
} else {
websWrite(wp, T("Group, \"%s\" was successfully added."),
group);
}
}
websMsgEnd(wp);
websFooter(wp);
websDone(wp, 200);
}
int dbSearchStr(int did, char_t *tablename,
char_t *colName, char_t *value, int flags)
{
int tid, nRows, nColumns, column;
int match = 0;
dbTable_t *pTable;
a_assert(tablename);
a_assert(colName);
a_assert(value);
tid = dbGetTableId(0, tablename);
a_assert(tid >= 0);
if ((tid >= 0) && (tid < dbMaxTables) && (dbListTables[tid] != NULL)) {
pTable = dbListTables[tid];
} else {
return DB_ERR_TABLE_NOT_FOUND;
}
nColumns = pTable->nColumns;
nRows = pTable->nRows;
column = GetColumnIndex(tid, colName);
a_assert (column >= 0);
if (column >= 0) {
char_t *compareVal;
int row, *pRow;
/*
* Scan through rows until we find a match.
* Note that some of these rows may be deleted!
*/
row = 0;
while (row < nRows) {
pRow = pTable->rows[row];
if (pRow) {
compareVal = (char_t *)(pRow[column]);
if (NULL != compareVal)
{
if (DB_CASE_INSENSITIVE == flags)
{
match = gstricmp(compareVal, value);
}
else
{
match = gstrcmp(compareVal, value);
}
if (0 == match)
{
return row;
}
}
}
row++;
}
} else {
/*
* Return -2 if search column was not found
*/
trace(3, T("DB: Unable to find column <%s> in table <%s>\n"),
colName, tablename);
return DB_ERR_COL_NOT_FOUND;
}
return -1;
}
int gui(int what, void *arg)
{
mixer_t *mixer = NULL;
stream_t *stream;
#ifdef CONFIG_DVDREAD
dvd_priv_t *dvd;
#endif
plItem *next;
if (guiInfo.mpcontext)
mixer = mpctx_get_mixer(guiInfo.mpcontext);
switch (what) {
case GUI_SET_CONTEXT:
guiInfo.mpcontext = arg;
break;
case GUI_SET_STATE:
switch ((int)arg) {
case GUI_STOP:
case GUI_PLAY:
// if ( !gtkShowVideoWindow ) wsVisibleWindow( &guiApp.subWindow,wsHideWindow );
case GUI_PAUSE:
guiInfo.Playing = (int)arg;
break;
}
uiState();
break;
case GUI_SET_FILE:
// if ( guiInfo.Playing == 1 && guiInfo.FilenameChanged )
if (guiInfo.FilenameChanged) {
audio_id = -1;
video_id = -1;
dvdsub_id = -1;
vobsub_id = -1;
stream_cache_size = -1;
autosync = 0;
dvd_title = 0;
force_fps = 0;
}
guiInfo.sh_video = NULL;
wsPostRedisplay(&guiApp.subWindow);
break;
case GUI_RUN_COMMAND:
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[interface] GUI_RUN_COMMAND: %d\n", (int)arg);
switch ((int)arg) {
case MP_CMD_VO_FULLSCREEN:
uiEventHandling(evFullScreen, 0);
break;
case MP_CMD_PLAY_TREE_STEP:
uiEventHandling(evNext, 0);
break;
case -MP_CMD_PLAY_TREE_STEP:
uiEventHandling(evPrev, 0);
break;
case MP_CMD_STOP:
uiEventHandling(evStop, 0);
break;
case MP_CMD_QUIT:
uiEventHandling(evExit, 0);
break;
}
break;
case GUI_PREPARE:
gui(GUI_SET_FILE, 0);
switch (guiInfo.StreamType) {
case STREAMTYPE_PLAYLIST:
break;
#ifdef CONFIG_VCD
case STREAMTYPE_VCD:
{
char tmp[512];
sprintf(tmp, "vcd://%d", guiInfo.Track + 1);
guiSetFilename(guiInfo.Filename, tmp);
}
break;
#endif
#ifdef CONFIG_DVDREAD
case STREAMTYPE_DVD:
{
char tmp[512];
sprintf(tmp, "dvd://%d", guiInfo.Title);
guiSetFilename(guiInfo.Filename, tmp);
}
dvd_chapter = guiInfo.Chapter;
dvd_angle = guiInfo.Angle;
break;
#endif
}
// if ( guiInfo.StreamType != STREAMTYPE_PLAYLIST ) // Does not make problems anymore!
{
if (guiInfo.Filename)
filename = gstrdup(guiInfo.Filename);
else if (filename)
guiSetFilename(guiInfo.Filename, filename);
}
// video opts
if (!video_driver_list) {
int i = 0;
while (video_out_drivers[i++]) {
if (video_out_drivers[i - 1]->control(VOCTRL_GUISUPPORT, NULL) == VO_TRUE) {
gaddlist(&video_driver_list, (char *)video_out_drivers[i - 1]->info->short_name);
break;
}
}
}
if (!video_driver_list && !video_driver_list[0]) {
gmp_msg(MSGT_GPLAYER, MSGL_FATAL, MSGTR_IDFGCVD);
guiExit(EXIT_ERROR);
}
{
int i = 0;
guiInfo.MovieWindow = True;
while (video_out_drivers[i++]) {
if (video_out_drivers[i - 1]->control(VOCTRL_GUISUPPORT, NULL) == VO_TRUE) {
if ((video_driver_list && !gstrcmp(video_driver_list[0], (char *)video_out_drivers[i - 1]->info->short_name)) && (video_out_drivers[i - 1]->control(VOCTRL_GUI_NOWINDOW, NULL) == VO_TRUE)) {
guiInfo.MovieWindow = False;
break;
}
}
}
}
#ifdef CONFIG_DXR3
if (video_driver_list && !gstrcmp(video_driver_list[0], "dxr3"))
if (guiInfo.StreamType != STREAMTYPE_DVD && guiInfo.StreamType != STREAMTYPE_VCD)
if (gtkVfLAVC)
add_vf("lavc");
#endif
if (gtkVfPP)
add_vf("pp");
// audio opts
// if ( ao_plugin_cfg.plugin_list ) { free( ao_plugin_cfg.plugin_list ); ao_plugin_cfg.plugin_list=NULL; }
if (gtkAONorm)
greplace(&af_cfg.list, "volnorm", "volnorm");
if (gtkEnableAudioEqualizer)
greplace(&af_cfg.list, "equalizer", "equalizer");
if (gtkAOExtraStereo) {
char *name;
name = malloc(12 + 20 + 1);
snprintf(name, 12 + 20, "extrastereo=%f", gtkAOExtraStereoMul);
name[12 + 20] = 0;
greplace(&af_cfg.list, "extrastereo", name);
free(name);
}
#ifdef CONFIG_OSS_AUDIO
if (audio_driver_list && !gstrncmp(audio_driver_list[0], "oss", 3)) {
char *tmp;
mixer_device = gtkAOOSSMixer;
mixer_channel = gtkAOOSSMixerChannel;
if (gtkAOOSSDevice) {
tmp = calloc(1, strlen(gtkAOOSSDevice) + 7);
sprintf(tmp, "oss:%s", gtkAOOSSDevice);
} else
tmp = strdup("oss");
gaddlist(&audio_driver_list, tmp);
free(tmp);
}
#endif
#ifdef CONFIG_ALSA
if (audio_driver_list && !gstrncmp(audio_driver_list[0], "alsa", 4)) {
char *tmp;
mixer_device = gtkAOALSAMixer;
mixer_channel = gtkAOALSAMixerChannel;
if (gtkAOALSADevice) {
tmp = calloc(1, strlen(gtkAOALSADevice) + 14);
sprintf(tmp, "alsa:device=%s", gtkAOALSADevice);
} else
tmp = strdup("alsa");
gaddlist(&audio_driver_list, tmp);
free(tmp);
}
#endif
#ifdef CONFIG_SDL
if (audio_driver_list && !gstrncmp(audio_driver_list[0], "sdl", 3)) {
char *tmp;
if (gtkAOSDLDriver) {
tmp = calloc(1, strlen(gtkAOSDLDriver) + 10);
sprintf(tmp, "sdl:%s", gtkAOSDLDriver);
} else
tmp = strdup("sdl");
gaddlist(&audio_driver_list, tmp);
free(tmp);
}
#endif
#ifdef CONFIG_ESD
if (audio_driver_list && !gstrncmp(audio_driver_list[0], "esd", 3)) {
char *tmp;
if (gtkAOESDDevice) {
tmp = calloc(1, strlen(gtkAOESDDevice) + 10);
sprintf(tmp, "esd:%s", gtkAOESDDevice);
} else
tmp = strdup("esd");
gaddlist(&audio_driver_list, tmp);
free(tmp);
}
#endif
// subtitle
// subdata->filename=gstrdup( guiInfo.Subtitlename );
stream_dump_type = 0;
if (gtkSubDumpMPSub)
stream_dump_type = 4;
if (gtkSubDumpSrt)
stream_dump_type = 6;
gtkSubDumpMPSub = gtkSubDumpSrt = 0;
guiLoadFont();
// misc
if (gtkCacheOn)
stream_cache_size = gtkCacheSize;
if (gtkAutoSyncOn)
autosync = gtkAutoSync;
if (guiInfo.AudioFile)
audio_stream = gstrdup(guiInfo.AudioFile);
else if (guiInfo.FilenameChanged)
gfree((void **)&audio_stream);
// audio_stream = NULL;
guiInfo.DiskChanged = 0;
guiInfo.FilenameChanged = 0;
guiInfo.NewPlay = 0;
#ifdef CONFIG_ASS
ass_enabled = gtkASS.enabled;
ass_use_margins = gtkASS.use_margins;
ass_top_margin = gtkASS.top_margin;
ass_bottom_margin = gtkASS.bottom_margin;
#endif
break;
case GUI_SET_STREAM:
stream = arg;
guiInfo.StreamType = stream->type;
switch (guiInfo.StreamType) {
#ifdef CONFIG_DVDREAD
case STREAMTYPE_DVD:
dvd = stream->priv;
guiInfo.DVD.titles = dvd->vmg_file->tt_srpt->nr_of_srpts;
guiInfo.DVD.chapters = dvd->vmg_file->tt_srpt->title[dvd_title].nr_of_ptts;
guiInfo.DVD.angles = dvd->vmg_file->tt_srpt->title[dvd_title].nr_of_angles;
guiInfo.DVD.nr_of_audio_channels = dvd->nr_of_channels;
memcpy(guiInfo.DVD.audio_streams, dvd->audio_streams, sizeof(dvd->audio_streams));
guiInfo.DVD.nr_of_subtitles = dvd->nr_of_subtitles;
memcpy(guiInfo.DVD.subtitles, dvd->subtitles, sizeof(dvd->subtitles));
guiInfo.DVD.current_title = dvd_title + 1;
guiInfo.DVD.current_chapter = dvd_chapter + 1;
guiInfo.DVD.current_angle = dvd_angle + 1;
guiInfo.Track = dvd_title + 1;
break;
#endif
#ifdef CONFIG_VCD
case STREAMTYPE_VCD:
guiInfo.VCDTracks = 0;
stream_control(stream, STREAM_CTRL_GET_NUM_CHAPTERS, &guiInfo.VCDTracks);
break;
#endif
default:
break;
}
break;
case GUI_SET_AFILTER:
guiInfo.afilter = arg;
break;
case GUI_SET_VIDEO:
// video
guiInfo.sh_video = arg;
if (arg) {
sh_video_t *sh = arg;
guiInfo.FPS = sh->fps;
}
if (guiInfo.StreamType == STREAMTYPE_STREAM)
btnSet(evSetMoviePosition, btnDisabled);
else
btnSet(evSetMoviePosition, btnReleased);
#ifdef CONFIG_DXR3
if (video_driver_list && !gstrcmp(video_driver_list[0], "dxr3") && (((demuxer_t *)mpctx_get_demuxer(guiInfo.mpcontext))->file_format != DEMUXER_TYPE_MPEG_PS) && !gtkVfLAVC) {
gtkMessageBox(GTK_MB_FATAL, MSGTR_NEEDLAVC);
return False;
}
#endif
break;
case GUI_SET_AUDIO:
guiInfo.AudioChannels = arg ? ((sh_audio_t *)arg)->channels : 0;
if (arg && !guiInfo.sh_video)
guiInfo.MovieWindow = False;
gui(GUI_SET_MIXER, 0);
if (gtkEnableAudioEqualizer) {
equalizer_t eq;
unsigned int i, j;
for (i = 0; i < FF_ARRAY_ELEMS(gtkEquChannels); i++) {
for (j = 0; j < FF_ARRAY_ELEMS(*gtkEquChannels); j++) {
eq.channel = i;
eq.band = j;
eq.gain = gtkEquChannels[i][j];
gtkSet(gtkSetEqualizer, 0, &eq);
}
}
}
wsVisibleWindow(&guiApp.subWindow, (guiInfo.MovieWindow ? wsShowWindow : wsHideWindow));
break;
case GUI_SET_MIXER:
if (mixer) {
float l, r;
static float last_balance = -1;
mixer_getvolume(mixer, &l, &r);
guiInfo.Volume = FFMAX(l, r);
btnModify(evSetVolume, guiInfo.Volume);
if (guiInfo.Balance != last_balance) {
if (guiInfo.Volume)
guiInfo.Balance = ((r - l) / guiInfo.Volume + 1.0) * 50.0;
else
guiInfo.Balance = 50.0f;
last_balance = guiInfo.Balance;
btnModify(evSetBalance, guiInfo.Balance);
}
}
break;
case GUI_REDRAW:
uiEventHandling(evRedraw, 0);
break;
case GUI_SETUP_VIDEO_WINDOW:
if (!guiApp.subWindow.isFullScreen) {
wsResizeWindow(&guiApp.subWindow, vo_dwidth, vo_dheight);
wsMoveWindow(&guiApp.subWindow, True, guiApp.sub.x, guiApp.sub.y);
}
guiInfo.MovieWidth = vo_dwidth;
guiInfo.MovieHeight = vo_dheight;
if (guiWinID >= 0)
wsMoveWindow(&guiApp.mainWindow, False, 0, vo_dheight);
WinID = guiApp.subWindow.WindowID;
break;
case GUI_X_EVENT:
guiInfo.event_struct = arg;
wsEvents(wsDisplay, arg);
gtkEventHandling();
break;
case GUI_END_FILE:
if (!uiGotoTheNext && guiInfo.Playing) {
uiGotoTheNext = 1;
break;
}
if (guiInfo.Playing && (next = gtkSet(gtkGetNextPlItem, 0, NULL)) && (plLastPlayed != next)) {
plLastPlayed = next;
guiSetDF(guiInfo.Filename, next->path, next->name);
guiInfo.StreamType = STREAMTYPE_FILE;
guiInfo.FilenameChanged = guiInfo.NewPlay = 1;
gfree((void **)&guiInfo.AudioFile);
gfree((void **)&guiInfo.Subtitlename);
} else {
if (guiInfo.FilenameChanged || guiInfo.NewPlay)
break;
guiInfo.TimeSec = 0;
guiInfo.Position = 0;
guiInfo.AudioChannels = 0;
guiInfo.MovieWindow = True;
#ifdef CONFIG_DVDREAD
guiInfo.DVD.current_title = 1;
guiInfo.DVD.current_chapter = 1;
guiInfo.DVD.current_angle = 1;
#endif
if (!guiApp.subWindow.isFullScreen && gtkShowVideoWindow) {
wsResizeWindow(&guiApp.subWindow, guiApp.sub.width, guiApp.sub.height);
wsMoveWindow(&guiApp.subWindow, True, guiApp.sub.x, guiApp.sub.y);
} else
wsVisibleWindow(&guiApp.subWindow, wsHideWindow);
gui(GUI_SET_STATE, (void *)GUI_STOP);
uiSubRender = 1;
wsSetBackgroundRGB(&guiApp.subWindow, guiApp.sub.R, guiApp.sub.G, guiApp.sub.B);
wsClearWindow(guiApp.subWindow);
wsPostRedisplay(&guiApp.subWindow);
}
break;
}
return True;
}
void ShowFileSelect( int type,int modal )
{
int i, k, fsMedium;
char * tmp = NULL, * dir = NULL;
struct stat f;
if ( fsFileSelect ) gtkActive( fsFileSelect );
else fsFileSelect=create_FileSelect();
fsType=type;
switch ( type )
{
case fsVideoSelector:
gtk_window_set_title( GTK_WINDOW( fsFileSelect ),MSGTR_FileSelect );
fsList_items=NULL;
for( i=0;fsVideoFilterNames[i][0];i++ )
fsList_items=g_list_append( fsList_items,fsVideoFilterNames[i][0] );
k = fsLastVideoFilterSelected;
gtk_combo_set_popdown_strings( GTK_COMBO( List ),fsList_items );
g_list_free( fsList_items );
gtk_entry_set_text( GTK_ENTRY( fsFilterCombo ),fsVideoFilterNames[k >= 0 ? k : i-2][0] );
tmp=guiInfo.Filename;
break;
case fsSubtitleSelector:
gtk_window_set_title( GTK_WINDOW( fsFileSelect ),MSGTR_SubtitleSelect );
fsList_items=NULL;
for( i=0;fsSubtitleFilterNames[i][0];i++ )
fsList_items=g_list_append( fsList_items,fsSubtitleFilterNames[i][0] );
k = fsLastSubtitleFilterSelected;
gtk_combo_set_popdown_strings( GTK_COMBO( List ),fsList_items );
g_list_free( fsList_items );
gtk_entry_set_text( GTK_ENTRY( fsFilterCombo ),fsSubtitleFilterNames[k >= 0 ? k : i-2][0] );
tmp=guiInfo.SubtitleFilename;
break;
/* case fsOtherSelector:
gtk_window_set_title( GTK_WINDOW( fsFileSelect ),MSGTR_OtherSelect );
fsList_items=NULL;
for( i=0;fsOtherFilterNames[i][0];i++ )
fsList_items=g_list_append( fsList_items,fsOtherFilterNames[i][0] );
gtk_combo_set_popdown_strings( GTK_COMBO( List ),fsList_items );
g_list_free( fsList_items );
gtk_entry_set_text( GTK_ENTRY( fsFilterCombo ),fsOtherFilterNames[0][0] );
tmp=guiInfo.Othername;
break;*/
case fsAudioSelector:
gtk_window_set_title( GTK_WINDOW( fsFileSelect ),MSGTR_AudioFileSelect );
fsList_items=NULL;
for( i=0;fsAudioFileNames[i][0];i++ )
fsList_items=g_list_append( fsList_items,fsAudioFileNames[i][0] );
k = fsLastAudioFilterSelected;
gtk_combo_set_popdown_strings( GTK_COMBO( List ),fsList_items );
g_list_free( fsList_items );
gtk_entry_set_text( GTK_ENTRY( fsFilterCombo ),fsAudioFileNames[k >= 0 ? k : i-2][0] );
tmp=guiInfo.AudioFilename;
break;
case fsFontSelector:
gtk_window_set_title( GTK_WINDOW( fsFileSelect ),MSGTR_FontSelect );
fsList_items=NULL;
for( i=0;fsFontFileNames[i][0];i++ )
fsList_items=g_list_append( fsList_items,fsFontFileNames[i][0] );
k = fsLastFontFilterSelected;
gtk_combo_set_popdown_strings( GTK_COMBO( List ),fsList_items );
g_list_free( fsList_items );
gtk_entry_set_text( GTK_ENTRY( fsFilterCombo ),fsFontFileNames[k >= 0 ? k : i-2][0] );
tmp=font_name;
break;
}
fsMedium=(fsType == fsVideoSelector || fsType == fsSubtitleSelector || fsType == fsAudioSelector);
if ( !tmp && fsMedium ) tmp=guiInfo.Filename;
if ( tmp && tmp[0] && !strstr( tmp,"://" ) )
{
dir = strdup( tmp );
do
{
char * c = strrchr( dir,'/' );
if ( ( stat( dir,&f ) != 0 ) || S_ISDIR( f.st_mode ) ) break;
if ( c ) *c=0;
} while ( strrchr( dir,'/' ) );
if ( !dir[0] ) nfree( dir );
}
if ( fsTopList_items ) g_list_free( fsTopList_items ); fsTopList_items=NULL;
{
unsigned int i, c = 1;
if ( fsMedium )
{
for ( i=0;i < FF_ARRAY_ELEMS(fsHistory);i++ )
if ( fsHistory[i] ) { fsTopList_items=g_list_append( fsTopList_items,fsHistory[i] ); if ( c ) c=gstrcmp( dir,fsHistory[i] ); }
}
if ( c && dir )
{
g_free( fsSelectedDirectoryUtf8 );
fsSelectedDirectoryUtf8=g_filename_to_utf8( dir, -1, NULL, NULL, NULL );
fsTopList_items=g_list_prepend( fsTopList_items,fsSelectedDirectoryUtf8 );
}
}
free( dir );
if ( getenv( "HOME" ) ) fsTopList_items=g_list_append( fsTopList_items,getenv( "HOME" ) );
else fsTopList_items=g_list_append( fsTopList_items,"/home" );
if (stat( "/media",&f ) == 0) fsTopList_items=g_list_append( fsTopList_items,"/media" );
if (stat( "/mnt",&f ) == 0) fsTopList_items=g_list_append( fsTopList_items,"/mnt" );
fsTopList_items=g_list_append( fsTopList_items,"/" );
gtk_combo_set_popdown_strings( GTK_COMBO( fsCombo4 ),fsTopList_items );
gtk_widget_grab_focus( fsFNameList );
if (fsLastFNameListSelected + 1 > ((GtkCList *)fsFNameList)->rows) fsLastFNameListSelected = 0;
((GtkCList *)fsFNameList)->focus_row = fsLastFNameListSelected;
gtk_clist_select_row( GTK_CLIST( fsFNameList ),fsLastFNameListSelected,1 );
fsLastFNameListSelected = 0;
gtk_window_set_modal( GTK_WINDOW( fsFileSelect ),modal );
gtk_widget_show( fsFileSelect );
}
static void formAddUser(webs_t wp, char_t *path, char_t *query)
{
char_t *userid, *pass1, *pass2, *group, *enabled, *ok;
bool_t bDisable;
int nCheck;
a_assert(wp);
userid = websGetVar(wp, T("user"), T(""));
pass1 = websGetVar(wp, T("password"), T(""));
pass2 = websGetVar(wp, T("passconf"), T(""));
group = websGetVar(wp, T("group"), T(""));
enabled = websGetVar(wp, T("enabled"), T(""));
ok = websGetVar(wp, T("ok"), T(""));
websHeader(wp);
websMsgStart(wp);
if (gstricmp(ok, T("ok")) != 0) {
websWrite(wp, T("Add User Cancelled"));
} else if (gstrcmp(pass1, pass2) != 0) {
websWrite(wp, T("Confirmation Password did not match."));
} else {
if (enabled && *enabled && (gstrcmp(enabled, T("on")) == 0)) {
bDisable = FALSE;
} else {
bDisable = TRUE;
}
nCheck = umAddUser(userid, pass1, group, 0, bDisable);
if (nCheck != 0) {
char_t * strError;
switch (nCheck) {
case UM_ERR_DUPLICATE:
strError = T("User already exists.");
break;
case UM_ERR_BAD_NAME:
strError = T("Invalid user name.");
break;
case UM_ERR_BAD_PASSWORD:
strError = T("Invalid password.");
break;
case UM_ERR_NOT_FOUND:
strError = T("Invalid or unselected group.");
break;
default:
strError = T("Error writing user record.");
break;
}
websWrite(wp, T("Unable to add user, \"%s\". %s"),
userid, strError);
} else {
websWrite(wp, T("User, \"%s\" was successfully added."),
userid);
}
}
websMsgEnd(wp);
websFooter(wp);
websDone(wp, 200);
}
int dbSearchStr(int did, char_t *tablename,
char_t *colName, char_t *value, int flags)
{
int tid, nRows, nColumns, column;
dbTable_t *pTable;
a_assert(tablename);
a_assert(colName);
a_assert(value);
tid = dbGetTableId(0, tablename);
a_assert(tid >= 0);
if ((tid >= 0) && (tid < dbMaxTables) && (dbListTables[tid] != NULL)) {
pTable = dbListTables[tid];
} else {
return DB_ERR_TABLE_NOT_FOUND;
}
nColumns = pTable->nColumns;
nRows = pTable->nRows;
column = GetColumnIndex(tid, colName);
a_assert (column >= 0);
if (column >= 0) {
char_t *compareVal;
int row, *pRow;
/*
* Scan through rows until we find a match.
* Note that some of these rows may be deleted!
*/
row = 0;
while (row < nRows) {
pRow = pTable->rows[row];
if (pRow) {
compareVal = (char_t *)(pRow[column]);
if (compareVal && (gstrcmp(compareVal, value) == 0)) {
return row;
}
/* Add by Dick Tam */
/* In order to protect everything inside a directory */
if (compareVal) {
if(gstrncmp(compareVal, value,gstrlen(compareVal)) == 0) {
return row;
}
}
/* Add by Dick Tam End */
}
row++;
}
} else {
/*
* Return -2 if search column was not found
*/
trace(3, T("DB: Unable to find column <%s> in table <%s>\n"),
colName, tablename);
return DB_ERR_COL_NOT_FOUND;
}
return -1;
}
