static int amd_get_pages(unsigned long addr, size_t size, int write, int force,
struct sg_table *sg_head,
void *client_context, void *core_context)
{
int ret;
struct amd_mem_context *mem_context =
(struct amd_mem_context *)client_context;
MSG_DBG("get_pages: addr:0x%lx,size:0x%x, core_context:%p\n",
addr, (unsigned int)size, core_context);
if (!mem_context) {
MSG_WARN("get_pages: Invalid client context");
return -EINVAL;
}
MSG_DBG("get_pages: pid :0x%p\n", mem_context->pid);
if (addr != mem_context->va) {
MSG_WARN("get_pages: Context address (0x%llx) is not the same",
mem_context->va);
return -EINVAL;
}
if (size != mem_context->size) {
MSG_WARN("get_pages: Context size (0x%llx) is not the same",
mem_context->size);
return -EINVAL;
}
ret = rdma_interface->get_pages(addr,
size,
mem_context->pid,
&mem_context->p2p_info,
free_callback,
mem_context);
if (ret || !mem_context->p2p_info) {
MSG_ERR("Could not rdma::get_pages failure: %d", ret);
return ret;
}
mem_context->core_context = core_context;
/* Note: At this stage it is OK not to fill sg_table */
return 0;
}
void FunctionCollectionEditor::slotAddClicked()
{
FunctionTree* ft;
ft = new FunctionTree(this);
if (ft->exec() == QDialog::Accepted && ft->deviceString() != QString::null && ft->functionString() != QString::null)
{
if (findItem(ft->deviceString(), ft->functionString()) == NULL)
{
new QListViewItem(m_functionList, ft->deviceString(), ft->functionString());
DMXDevice* device = _app->doc()->searchDevice(ft->deviceString());
Function* function = device->searchFunction(ft->functionString());
if (function == NULL)
{
function = device->deviceClass()->searchFunction(ft->functionString());
}
ASSERT(function != NULL);
ASSERT(m_functionCollection != NULL);
m_functionCollection->addItem(device, function);
}
else
{
MSG_WARN("The selected device/function is already present in the current collection.\nOperation aborted.");
}
}
}
SwsFunc yuv2rgb_get_func_ptr (SwsContext *c)
{
#if defined(ARCH_X86) || defined(ARCH_X86_64)
if(c->params.cpu & SWS_CPU_CAPS_MMX2){
switch(c->dstFormat){
case IMGFMT_BGR32: return yuv420_rgb32_MMX2;
case IMGFMT_BGR24: return yuv420_rgb24_MMX2;
case IMGFMT_BGR16: return yuv420_rgb16_MMX2;
case IMGFMT_BGR15: return yuv420_rgb15_MMX2;
}
}
if(c->params.cpu & SWS_CPU_CAPS_MMX){
switch(c->dstFormat){
case IMGFMT_BGR32: return yuv420_rgb32_MMX;
case IMGFMT_BGR24: return yuv420_rgb24_MMX;
case IMGFMT_BGR16: return yuv420_rgb16_MMX;
case IMGFMT_BGR15: return yuv420_rgb15_MMX;
}
}
#endif
#ifdef HAVE_MLIB
{
SwsFunc t= yuv2rgb_init_mlib(c);
if(t) return t;
}
#endif
#ifdef HAVE_ALTIVEC
if (c->params.cpu & SWS_CPU_CAPS_ALTIVEC)
{
SwsFunc t = yuv2rgb_init_altivec(c);
if(t) return t;
}
#endif
MSG_WARN("No accelerated colorspace conversion found\n");
switch(c->dstFormat){
case IMGFMT_RGB32:
case IMGFMT_BGR32: return yuv2rgb_c_32;
case IMGFMT_RGB24: return yuv2rgb_c_24_rgb;
case IMGFMT_BGR24: return yuv2rgb_c_24_bgr;
case IMGFMT_RGB16:
case IMGFMT_BGR16:
case IMGFMT_RGB15:
case IMGFMT_BGR15: return yuv2rgb_c_16;
case IMGFMT_RGB8:
case IMGFMT_BGR8: return yuv2rgb_c_8_ordered_dither;
case IMGFMT_RGB4:
case IMGFMT_BGR4: return yuv2rgb_c_4_ordered_dither;
case IMGFMT_RG4B:
case IMGFMT_BG4B: return yuv2rgb_c_4b_ordered_dither;
case IMGFMT_RGB1:
case IMGFMT_BGR1: return yuv2rgb_c_1_ordered_dither;
default:
assert(0);
}
return NULL;
}
/* this is the routine called by libjpeg when it detects an error. */
METHODDEF(void) Jpeg_errorexit (j_common_ptr cinfo)
{
/* display message and return to setjmp buffer */
my_error_ptr myerr = (my_error_ptr) cinfo->err;
if (prefs.show_msg) {
DilloJpeg *jpeg =
((my_source_mgr *) ((j_decompress_ptr) cinfo)->src)->jpeg;
MSG_WARN("\"%s\": ", URL_STR(jpeg->url));
(*cinfo->err->output_message) (cinfo);
}
longjmp(myerr->setjmp_buffer, 1);
}
/*
* Allocate and set a new entry in the cache list
*/
static CacheEntry_t *Cache_entry_add(const DilloUrl *Url)
{
CacheEntry_t *old_entry, *new_entry;
if ((old_entry = Cache_entry_search(Url))) {
MSG_WARN("Cache_entry_add, leaking an entry.\n");
dList_remove(CachedURLs, old_entry);
}
new_entry = dNew(CacheEntry_t, 1);
Cache_entry_init(new_entry, Url); /* Set safe values */
dList_insert_sorted(CachedURLs, new_entry, Cache_entry_cmp);
return new_entry;
}
bool Doc::readDeviceClasses()
{
DeviceClass* dc = NULL;
QString path = QString::null;
QString dir = _app->settings()->deviceClassPath();
QDir d(dir);
d.setFilter(QDir::Files);
d.setNameFilter("*.deviceclass");
if (d.exists() == false || d.isReadable() == false)
{
MSG_WARN("Unable to open or read from device directory! Check settings and permissions.");
return false;
}
QStringList dirlist(d.entryList());
QStringList::Iterator it;
QList <QString> list; // Our stringlist that contains the files' contents
// Put a slash to the end of the directory name if it isn't there
if (dir.right(1) != QString("/"))
{
dir = dir + QString("/");
}
// Go thru all files
for (it = dirlist.begin(); it != dirlist.end(); ++it)
{
path = dir + *it;
readFileToList(path, list);
dc = createDeviceClass(list);
if (dc != NULL)
{
dc->setFile(path);
m_deviceClassList.append(dc);
}
// 03-Jan-2002 / HJu
// The list wasn't cleared between files
while (list.isEmpty() == false)
{
list.first();
delete list.take();
}
}
return true;
}
/*
* CCC function for the HTTP module
*/
void a_Http_ccc(int Op, int Branch, int Dir, ChainLink *Info,
void *Data1, void *Data2)
{
int SKey = VOIDP2INT(Info->LocalKey);
(void)Data2; /* suppress unused parameter warning */
dReturn_if_fail( a_Chain_check("a_Http_ccc", Op, Branch, Dir, Info) );
if (Branch == 1) {
if (Dir == BCK) {
/* HTTP query branch */
switch (Op) {
case OpStart:
/* ( Data1 = Web ) */
SKey = Http_sock_new();
Info->LocalKey = INT2VOIDP(SKey);
/* link IO */
a_Chain_link_new(Info, a_Http_ccc, BCK, a_IO_ccc, 1, 1);
a_Chain_bcb(OpStart, Info, NULL, NULL);
/* async. connection */
Http_get(Info, Data1);
break;
case OpEnd:
/* finished the HTTP query branch */
a_Chain_bcb(OpEnd, Info, NULL, NULL);
Http_socket_free(SKey);
dFree(Info);
break;
case OpAbort:
/* something bad happened... */
a_Chain_bcb(OpAbort, Info, NULL, NULL);
Http_socket_free(SKey);
dFree(Info);
break;
}
} else { /* 1 FWD */
/* HTTP send-query status branch */
switch (Op) {
default:
MSG_WARN("Unused CCC\n");
break;
}
}
}
}
/*
* Set a timeout function to ask for user/password.
*/
static void Cache_auth_entry(CacheEntry_t *entry, BrowserWindow *bw)
{
static int busy = 0;
CacheAuthData_t *data;
if (!entry) {
busy = 0;
} else if (busy) {
MSG_WARN("Cache_auth_entry: caught busy!\n");
} else if (entry->Auth) {
busy = 1;
data = dNew(CacheAuthData_t, 1);
data->auth = entry->Auth;
data->url = a_Url_dup(entry->Url);
data->bw = bw;
entry->Auth = NULL;
a_Timeout_add(0.0, Cache_auth_callback, data);
}
}
static void free_callback(void *client_priv)
{
struct amd_mem_context *mem_context =
(struct amd_mem_context *)client_priv;
MSG_DBG("free_callback: data 0x%p\n", mem_context);
if (!mem_context) {
MSG_WARN("free_callback: Invalid client context");
return;
}
MSG_DBG("mem_context->core_context 0x%p\n", mem_context->core_context);
/* Call back IB stack asking to invalidate memory */
(*ib_invalidate_callback) (ib_reg_handle, mem_context->core_context);
/* amdkfd will freed resources when we returned from this callback.
* Set flag to inform that there is nothing to do on "put_pages", etc.
*/
ACCESS_ONCE(mem_context->free_callback_called) = 1;
}
/*
* Parse authentication challenge into token-value pairs
* and feed them into the callback function.
*
* The parsing is aborted should the callback function return 0.
*
* Return: 1 if the parse succeeds, 0 otherwise.
*/
static int Auth_parse_token_value(AuthParse_t *auth_parse, char **auth,
Auth_parse_token_value_callback_t *callback)
{
char keep_going, expect_quoted;
char *token, *beyond_token;
Dstr *value;
size_t *token_size;
while (**auth) {
_MSG("Auth_parse_token_value: remaining: %s\n", *auth);
/* parse a token */
token = *auth;
token_size = 0;
while (Auth_is_token_char(**auth)) {
(*auth)++;
token_size++;
}
if (token_size == 0) {
MSG("Auth_parse_token_value: missing auth token\n");
return 0;
}
beyond_token = *auth;
/* skip linear whitespace characters */
while (**auth == ' ' || **auth == '\t')
(*auth)++;
/* parse the '=' */
switch (*(*auth)++) {
case '=':
*beyond_token = '\0';
break;
case '\0':
case ',':
MSG("Auth_parse_token_value: missing auth token value\n");
return 0;
break;
default:
MSG("Auth_parse_token_value: garbage after auth token\n");
return 0;
break;
}
value = Auth_unquote_value(auth);
expect_quoted = !(strcmp(token, "stale") == 0 ||
strcmp(token, "algorithm") == 0);
if (((*auth)[-1] == '"') != expect_quoted)
MSG_WARN("Auth_parse_token_value: "
"Values for key %s should%s be quoted.\n",
token, expect_quoted ? "" : " not");
keep_going = callback(auth_parse, token, value->str);
dStr_free(value, 1);
if (!keep_going)
break;
/* skip ' ' and ',' */
while ((**auth == ' ') || (**auth == ','))
(*auth)++;
}
return 1;
}
int Cookies_rc_check()
{
const int line_maxlen = 4096;
FILE *stream;
char *filename;
char line[line_maxlen];
bool_t default_deny = TRUE;
/* Get a file pointer */
filename = dStrconcat(dGethomedir(), "/.dillo/cookiesrc", NULL);
stream = fopen(filename, "r");
dFree(filename);
if (!stream) {
MSG_ERR("Cannot run test; cannot open cookiesrc.\n");
return 1;
}
/* Get all lines in the file */
while (!feof(stream)) {
char *rc;
line[0] = '\0';
rc = fgets(line, line_maxlen, stream);
if (!rc && ferror(stream)) {
MSG_ERR("Error while reading rule from cookiesrc: %s\n",
dStrerror(errno));
fclose(stream);
return 2;
}
/* Remove leading and trailing whitespaces */
dStrstrip(line);
if (line[0] != '\0' && line[0] != '#') {
int domain_end, i = 0;
const char *rule;
/* Get the domain */
while (line[i] != '\0' && !dIsspace(line[i]))
i++;
domain_end = i;
/* Skip past whitespace */
while (dIsspace(line[i]))
i++;
line[domain_end] = '\0';
/* Get the rule */
rule = line + i;
while (line[i] != '\0' && !dIsspace(line[i]))
i++;
line[i] = '\0';
if (!dStrAsciiCasecmp(line, "DEFAULT")) {
if (!dStrAsciiCasecmp(rule, "ACCEPT") ||
!dStrAsciiCasecmp(rule, "ACCEPT_SESSION"))
default_deny = FALSE;
} else {
if (!dStrAsciiCasecmp(rule, "DENY"))
MSG_WARN("DENY rules in cookiesrc can interfere with test.\n");
}
}
}
fclose(stream);
if (default_deny) {
MSG_ERR("Cannot run test with cookiesrc default of deny.\n");
return 1;
} else {
return 0;
}
}
/*
* CCC function for the CAPI module
*/
void a_Capi_ccc(int Op, int Branch, int Dir, ChainLink *Info,
void *Data1, void *Data2)
{
capi_conn_t *conn;
dReturn_if_fail( a_Chain_check("a_Capi_ccc", Op, Branch, Dir, Info) );
if (Branch == 1) {
if (Dir == BCK) {
/* Command sending branch */
switch (Op) {
case OpStart:
/* Data1 = conn; Data2 = {Web | server} */
conn = Data1;
Capi_conn_ref(conn);
Info->LocalKey = conn;
conn->InfoSend = Info;
if (strcmp(conn->server, "http") == 0) {
a_Chain_link_new(Info, a_Capi_ccc, BCK, a_Http_ccc, 1, 1);
a_Chain_bcb(OpStart, Info, Data2, NULL);
} else {
a_Chain_link_new(Info, a_Capi_ccc, BCK, a_Dpi_ccc, 1, 1);
a_Chain_bcb(OpStart, Info, Data2, NULL);
}
break;
case OpSend:
/* Data1 = dbuf */
a_Chain_bcb(OpSend, Info, Data1, NULL);
break;
case OpEnd:
conn = Info->LocalKey;
conn->InfoSend = NULL;
a_Chain_bcb(OpEnd, Info, NULL, NULL);
Capi_conn_unref(conn);
dFree(Info);
break;
case OpAbort:
conn = Info->LocalKey;
conn->InfoSend = NULL;
a_Chain_bcb(OpAbort, Info, NULL, NULL);
Capi_conn_unref(conn);
dFree(Info);
break;
default:
MSG_WARN("Unused CCC\n");
break;
}
} else { /* 1 FWD */
/* Command sending branch (status) */
switch (Op) {
case OpSend:
if (!Data2) {
MSG_WARN("Capi.c: Opsend [1F] Data2 = NULL\n");
} else if (strcmp(Data2, "FD") == 0) {
conn = Info->LocalKey;
conn->SockFD = *(int*)Data1;
/* communicate the FD through the answer branch */
a_Capi_ccc(OpSend, 2, BCK, conn->InfoRecv, &conn->SockFD, "FD");
} else if (strcmp(Data2, "DpidOK") == 0) {
/* resume pending dpi requests */
Capi_conn_resume();
}
break;
case OpAbort:
conn = Info->LocalKey;
conn->InfoSend = NULL;
if (Data2) {
if (!strcmp(Data2, "DpidERROR")) {
a_UIcmd_set_msg(conn->bw,
"ERROR: can't start dpid daemon "
"(URL scheme = '%s')!",
conn->url ? URL_SCHEME(conn->url) : "");
} else if (!strcmp(Data2, "Both") && conn->InfoRecv) {
/* abort the other branch too */
a_Capi_ccc(OpAbort, 2, BCK, conn->InfoRecv, NULL, NULL);
}
}
/* if URL == expect-url */
a_Nav_cancel_expect_if_eq(conn->bw, conn->url);
/* finish conn */
Capi_conn_unref(conn);
dFree(Info);
break;
default:
MSG_WARN("Unused CCC\n");
break;
}
}
} else if (Branch == 2) {
if (Dir == BCK) {
/* Answer branch */
switch (Op) {
case OpStart:
/* Data1 = conn; Data2 = {"http" | "<dpi server name>"} */
conn = Data1;
Capi_conn_ref(conn);
Info->LocalKey = conn;
conn->InfoRecv = Info;
a_Chain_link_new(Info, a_Capi_ccc, BCK, a_Dpi_ccc, 2, 2);
a_Chain_bcb(OpStart, Info, NULL, Data2);
break;
case OpSend:
/* Data1 = FD */
if (Data2 && strcmp(Data2, "FD") == 0) {
a_Chain_bcb(OpSend, Info, Data1, Data2);
}
break;
case OpAbort:
conn = Info->LocalKey;
conn->InfoRecv = NULL;
a_Chain_bcb(OpAbort, Info, NULL, NULL);
/* remove the cache entry for this URL */
a_Cache_entry_remove_by_url(conn->url);
Capi_conn_unref(conn);
dFree(Info);
break;
default:
MSG_WARN("Unused CCC\n");
break;
}
} else { /* 2 FWD */
/* Server listening branch */
switch (Op) {
case OpSend:
conn = Info->LocalKey;
if (strcmp(Data2, "send_page_2eof") == 0) {
/* Data1 = dbuf */
DataBuf *dbuf = Data1;
a_Cache_process_dbuf(IORead, dbuf->Buf, dbuf->Size, conn->url);
} else if (strcmp(Data2, "send_status_message") == 0) {
a_UIcmd_set_msg(conn->bw, "%s", Data1);
} else if (strcmp(Data2, "chat") == 0) {
a_UIcmd_set_msg(conn->bw, "%s", Data1);
a_Bookmarks_chat_add(NULL, NULL, Data1);
} else if (strcmp(Data2, "dialog") == 0) {
a_Dpiapi_dialog(conn->bw, conn->server, Data1);
} else if (strcmp(Data2, "reload_request") == 0) {
a_Nav_reload(conn->bw);
} else if (strcmp(Data2, "start_send_page") == 0) {
/* prepare the cache to receive the data stream for this URL
*
* a_Capi_open_url() already added a new cache entry,
* and a client for it.
*/
}
break;
case OpEnd:
conn = Info->LocalKey;
conn->InfoRecv = NULL;
a_Cache_process_dbuf(IOClose, NULL, 0, conn->url);
if (conn->InfoSend) {
/* Propagate OpEnd to the sending branch too */
a_Capi_ccc(OpEnd, 1, BCK, conn->InfoSend, NULL, NULL);
}
Capi_conn_unref(conn);
dFree(Info);
break;
default:
MSG_WARN("Unused CCC\n");
break;
}
}
}
}
/*
* Most used function for requesting a URL.
* TODO: clean up the ad-hoc bindings with an API that allows dynamic
* addition of new plugins.
*
* Return value: A primary key for identifying the client,
* 0 if the client is aborted in the process.
*/
int a_Capi_open_url(DilloWeb *web, CA_Callback_t Call, void *CbData)
{
int reload;
char *cmd, *server;
capi_conn_t *conn = NULL;
const char *scheme = URL_SCHEME(web->url);
int safe = 0, ret = 0, use_cache = 0;
/* reload test */
reload = (!(a_Capi_get_flags(web->url) & CAPI_IsCached) ||
(URL_FLAGS(web->url) & URL_E2EQuery));
if (web->flags & WEB_Download) {
/* download request: if cached save from cache, else
* for http, ftp or https, use the downloads dpi */
if (a_Capi_get_flags_with_redirection(web->url) & CAPI_IsCached) {
if (web->filename) {
if ((web->stream = fopen(web->filename, "w"))) {
use_cache = 1;
} else {
MSG_WARN("Cannot open \"%s\" for writing.\n", web->filename);
}
}
} else if (a_Cache_download_enabled(web->url)) {
server = "downloads";
cmd = Capi_dpi_build_cmd(web, server);
a_Capi_dpi_send_cmd(web->url, web->bw, cmd, server, 1);
dFree(cmd);
}
} else if (Capi_url_uses_dpi(web->url, &server)) {
/* dpi request */
if ((safe = a_Capi_dpi_verify_request(web->bw, web->url))) {
if (dStrcasecmp(scheme, "dpi") == 0) {
/* make "dpi:/" prefixed urls always reload. */
a_Url_set_flags(web->url, URL_FLAGS(web->url) | URL_E2EQuery);
reload = 1;
}
if (reload) {
a_Capi_conn_abort_by_url(web->url);
/* Send dpip command */
cmd = Capi_dpi_build_cmd(web, server);
a_Capi_dpi_send_cmd(web->url, web->bw, cmd, server, 1);
dFree(cmd);
}
use_cache = 1;
}
dFree(server);
} else if (!dStrcasecmp(scheme, "http")) {
/* http request */
if (reload) {
a_Capi_conn_abort_by_url(web->url);
/* create a new connection and start the CCC operations */
conn = Capi_conn_new(web->url, web->bw, "http", "none");
/* start the reception branch before the query one because the DNS
* may callback immediatly. This may avoid a race condition. */
a_Capi_ccc(OpStart, 2, BCK, a_Chain_new(), conn, "http");
a_Capi_ccc(OpStart, 1, BCK, a_Chain_new(), conn, web);
}
use_cache = 1;
} else if (!dStrcasecmp(scheme, "about")) {
/* internal request */
use_cache = 1;
}
if (use_cache) {
if (!conn || (conn && Capi_conn_valid(conn))) {
/* not aborted, let's continue... */
ret = a_Cache_open_url(web, Call, CbData);
}
} else {
a_Web_free(web);
}
return ret;
}
