struct ccnl_face_s *
ccnl_face_remove(struct ccnl_relay_s *ccnl, struct ccnl_face_s *f)
{
struct ccnl_face_s *f2;
struct ccnl_interest_s *pit;
struct ccnl_forward_s **ppfwd;
DEBUGMSG(1, "ccnl_face_remove relay=%p face=%p\n", (void *) ccnl, (void *) f);
ccnl_sched_destroy(f->sched);
ccnl_frag_destroy(f->frag);
for (pit = ccnl->pit; pit;) {
struct ccnl_pendint_s **ppend, *pend;
if (pit->from == f) {
pit->from = NULL;
}
for (ppend = &pit->pending; *ppend;) {
if ((*ppend)->face == f) {
pend = *ppend;
*ppend = pend->next;
ccnl_free(pend);
}
else {
ppend = &(*ppend)->next;
}
}
if (pit->pending) {
pit = pit->next;
}
else {
pit = ccnl_interest_remove(ccnl, pit);
}
}
for (ppfwd = &ccnl->fib; *ppfwd;) {
if ((*ppfwd)->face == f) {
struct ccnl_forward_s *pfwd = *ppfwd;
*ppfwd = pfwd->next;
ccnl_forward_remove(ccnl, pfwd);
}
else {
ppfwd = &(*ppfwd)->next;
}
}
while (f->outq) {
struct ccnl_buf_s *tmp = f->outq->next;
ccnl_free(f->outq);
f->outq = tmp;
}
#if ENABLE_DEBUG
ccnl_face_print_stat(f);
#endif
f2 = f->next;
DBL_LINKED_LIST_REMOVE(ccnl->faces, f);
ccnl_free(f);
return f2;
}
int
netsnmp_scalar_group_helper_handler(netsnmp_mib_handler *handler,
netsnmp_handler_registration *reginfo,
netsnmp_agent_request_info *reqinfo,
netsnmp_request_info *requests)
{
netsnmp_variable_list *var = requests->requestvb;
netsnmp_scalar_group *sgroup = (netsnmp_scalar_group *)handler->myvoid;
int ret, cmp;
int namelen;
oid subid;
DEBUGMSGTL(("helper:scalar_group", "Got request:\n"));
namelen = SNMP_MIN(requests->requestvb->name_length,
reginfo->rootoid_len);
cmp = snmp_oid_compare(requests->requestvb->name, namelen,
reginfo->rootoid, reginfo->rootoid_len);
DEBUGMSGTL(( "helper:scalar_group", " oid:", cmp));
DEBUGMSGOID(("helper:scalar_group", var->name, var->name_length));
DEBUGMSG(( "helper:scalar_group", "\n"));
ret = SNMP_ERR_NOCREATION;
switch (reqinfo->mode) {
/*
* The handling of "exact" requests is basically the same.
* The only difference between GET and SET requests is the
* error/exception to return on failure.
*/
case MODE_GET:
ret = SNMP_NOSUCHOBJECT;
/* Fallthrough */
case MODE_SET_RESERVE1:
case MODE_SET_RESERVE2:
case MODE_SET_ACTION:
case MODE_SET_COMMIT:
case MODE_SET_UNDO:
case MODE_SET_FREE:
if (cmp != 0 ||
requests->requestvb->name_length <= reginfo->rootoid_len) {
/*
* Common prefix doesn't match, or only *just* matches
* the registered root (so can't possibly match a scalar)
*/
netsnmp_set_request_error(reqinfo, requests, ret);
return SNMP_ERR_NOERROR;
} else {
/*
* Otherwise,
* extract the object subidentifier from the request,
* check this is (probably) valid, and then fudge the
* registered 'rootoid' to match, before passing the
* request off to the next handler ('scalar').
*
* Note that we don't bother checking instance subidentifiers
* here. That's left to the scalar helper.
*/
subid = requests->requestvb->name[reginfo->rootoid_len];
if (subid < sgroup->lbound ||
subid > sgroup->ubound) {
netsnmp_set_request_error(reqinfo, requests, ret);
return SNMP_ERR_NOERROR;
}
reginfo->rootoid[reginfo->rootoid_len++] = subid;
ret = netsnmp_call_next_handler(handler, reginfo, reqinfo,
requests);
reginfo->rootoid_len--;
return ret;
}
break;
case MODE_GETNEXT:
/*
* If we're being asked for something before (or exactly matches)
* the registered root OID, then start with the first object.
* If we're being asked for something that exactly matches an object
* OID, then that's what we pass down.
* Otherwise, we pass down the OID of the *next* object....
*/
if (cmp < 0 ||
requests->requestvb->name_length <= reginfo->rootoid_len) {
subid = sgroup->lbound;
} else if (requests->requestvb->name_length == reginfo->rootoid_len+1)
subid = requests->requestvb->name[reginfo->rootoid_len];
else
subid = requests->requestvb->name[reginfo->rootoid_len]+1;
/*
* ... always assuming this is (potentially) valid, of course.
*/
if (subid > sgroup->ubound)
return SNMP_ERR_NOERROR;
reginfo->rootoid[reginfo->rootoid_len++] = subid;
ret = netsnmp_call_next_handler(handler, reginfo, reqinfo,
requests);
/*
* If we didn't get an answer (due to holes in the group)
* set things up to retry again.
*/
if (!requests->delegated &&
(requests->requestvb->type == ASN_NULL ||
requests->requestvb->type == SNMP_NOSUCHOBJECT ||
requests->requestvb->type == SNMP_NOSUCHINSTANCE)) {
snmp_set_var_objid(requests->requestvb,
reginfo->rootoid, reginfo->rootoid_len);
requests->requestvb->name[reginfo->rootoid_len-1] = ++subid;
requests->requestvb->type = ASN_PRIV_RETRY;
}
reginfo->rootoid_len--;
return ret;
}
/*
* got here only if illegal mode found
*/
return SNMP_ERR_GENERR;
}
struct ccnl_buf_s *
ccnl_extract_prefix_nonce_ppkd(unsigned char **data, int *datalen, int *scope,
int *aok, int *min, int *max, struct ccnl_prefix_s **prefix,
struct ccnl_buf_s **nonce, struct ccnl_buf_s **ppkd,
unsigned char **content, int *contlen)
{
unsigned char *start = *data - 2, *cp;
int num, typ, len;
struct ccnl_prefix_s *p;
struct ccnl_buf_s *buf, *n = 0, *pub = 0;
DEBUGMSG(99, "ccnl_extract_prefix\n");
p = (struct ccnl_prefix_s *) ccnl_calloc(1, sizeof(struct ccnl_prefix_s));
if (!p) {
puts("can't get more memory from malloc, dropping ccn msg...");
return NULL;
}
p->comp = (unsigned char **) ccnl_malloc(
CCNL_MAX_NAME_COMP * sizeof(unsigned char **));
p->complen = (int *) ccnl_malloc(CCNL_MAX_NAME_COMP * sizeof(int));
if (!p->comp || !p->complen) {
puts("can't get more memory from malloc, dropping ccn msg...");
goto Bail;
}
while (dehead(data, datalen, &num, &typ) == 0) {
if (num == 0 && typ == 0) {
break; // end
}
if (typ == CCN_TT_DTAG) {
if (num == CCN_DTAG_NAME) {
while (1) {
if (dehead(data, datalen, &num, &typ) != 0) {
goto Bail;
}
if (num == 0 && typ == 0) {
break;
}
if (typ == CCN_TT_DTAG && num == CCN_DTAG_COMPONENT
&& p->compcnt < CCNL_MAX_NAME_COMP) {
if (hunt_for_end(data, datalen, p->comp + p->compcnt,
p->complen + p->compcnt) < 0) {
goto Bail;
}
p->compcnt++;
}
else {
if (consume(typ, num, data, datalen, 0, 0) < 0) {
goto Bail;
}
}
}
continue;
}
if (num == CCN_DTAG_SCOPE || num == CCN_DTAG_NONCE
|| num == CCN_DTAG_MINSUFFCOMP
|| num == CCN_DTAG_MAXSUFFCOMP
|| num == CCN_DTAG_PUBPUBKDIGEST) {
if (hunt_for_end(data, datalen, &cp, &len) < 0) {
goto Bail;
}
if (num == CCN_DTAG_SCOPE && len == 1 && scope) {
*scope = isdigit(*cp) && (*cp < '3') ? *cp - '0' : -1;
}
if (num == CCN_DTAG_ANSWERORIGKIND && aok) {
*aok = data2uint(cp, len);
}
if (num == CCN_DTAG_MINSUFFCOMP && min) {
*min = data2uint(cp, len);
}
if (num == CCN_DTAG_MAXSUFFCOMP && max) {
*max = data2uint(cp, len);
}
if (num == CCN_DTAG_NONCE && !n) {
n = ccnl_buf_new(cp, len);
}
if (num == CCN_DTAG_PUBPUBKDIGEST && !pub) {
pub = ccnl_buf_new(cp, len);
}
if (num == CCN_DTAG_EXCLUDE) {
DEBUGMSG(49, "warning: 'exclude' field ignored\n");
}
else {
continue;
}
}
if (num == CCN_DTAG_CONTENT || num == CCN_DTAG_CONTENTOBJ) {
if (consume(typ, num, data, datalen, content, contlen) < 0) {
goto Bail;
}
continue;
}
}
if (consume(typ, num, data, datalen, 0, 0) < 0) {
goto Bail;
}
}
if (prefix) {
p->comp[p->compcnt] = NULL;
*prefix = p;
}
else {
free_prefix(p);
}
if (nonce) {
*nonce = n;
}
else {
ccnl_free(n);
}
if (ppkd) {
*ppkd = pub;
}
else {
ccnl_free(pub);
}
buf = ccnl_buf_new(start, *data - start);
if (!buf) {
puts("can't get more memory from malloc, dropping ccn msg...");
}
// carefully rebase ptrs to new buf because of 64bit pointers:
if (content) {
*content = buf->data + (*content - start);
}
for (num = 0; num < p->compcnt; num++) {
p->comp[num] = buf->data + (p->comp[num] - start);
}
return buf;
Bail:
free_prefix(p);
free_2ptr_list(n, pub);
return NULL;
}
struct ccnl_face_s *
ccnl_get_face_or_create(struct ccnl_relay_s *ccnl, int ifndx, uint16_t sender_id)
{
struct ccnl_face_s *f;
for (f = ccnl->faces; f; f = f->next) {
if (ifndx == f->ifndx && (f->faceid == sender_id)) {
DEBUGMSG(1, "face found! ifidx=%d sender_id=%d faceid=%d\n", ifndx, sender_id, f->faceid);
ccnl_get_timeval(&f->last_used);
return f;
}
}
f = (struct ccnl_face_s *) ccnl_calloc(1, sizeof(struct ccnl_face_s));
if (!f) {
return NULL;
}
f->faceid = sender_id;
f->ifndx = ifndx;
if (sender_id == RIOT_BROADCAST) {
f->flags |= CCNL_FACE_FLAGS_BROADCAST;
}
if (ifndx >= 0) {
if (ccnl->defaultFaceScheduler)
f->sched = ccnl->defaultFaceScheduler(ccnl,
(void ( *)(void *, void *)) ccnl_face_CTS);
if (ccnl->ifs[ifndx].reflect) {
f->flags |= CCNL_FACE_FLAGS_REFLECT;
}
if (ccnl->ifs[ifndx].fwdalli) {
f->flags |= CCNL_FACE_FLAGS_FWDALLI;
}
}
f->peer.id = sender_id;
#ifdef USE_FRAG
if (ifndx == RIOT_TRANS_IDX) {
// if newly created face, no fragment policy is defined yet
// turning on fragmentation for riot trans dev based faces
int flagval = CCNL_FACE_FLAGS_STATIC;
f->flags = flagval &
(CCNL_FACE_FLAGS_STATIC | CCNL_FACE_FLAGS_REFLECT);
if (f->frag) {
ccnl_frag_destroy(f->frag);
f->frag = NULL;
}
int mtu = ccnl->ifs[f->ifndx].mtu;
f->frag = ccnl_frag_new(CCNL_FRAG_CCNx2013, mtu); //TODO
}
#endif
ccnl_get_timeval(&f->last_used);
DBL_LINKED_LIST_ADD(ccnl->faces, f);
return f;
}
void MMSFB_SetError(const int rc, const string msg) {
MMSFB_LastErrorString = MMSFB_ErrorString(rc, msg);
DEBUGMSG("MMSGUI", MMSFB_LastErrorString);
}
int ccnl_core_RX_i_or_c(struct ccnl_relay_s *relay, struct ccnl_face_s *from,
unsigned char **data, int *datalen)
{
int rc = -1, scope = 3, aok = 3, minsfx = 0, maxsfx = CCNL_MAX_NAME_COMP,
contlen;
struct ccnl_buf_s *buf = 0, *nonce = 0, *ppkd = 0;
struct ccnl_interest_s *i = 0;
struct ccnl_content_s *c = 0;
struct ccnl_prefix_s *p = 0;
unsigned char *content = 0;
DEBUGMSG(1, "ccnl_core_RX_i_or_c: (%d bytes left)\n", *datalen);
buf = ccnl_extract_prefix_nonce_ppkd(data, datalen, &scope, &aok, &minsfx,
&maxsfx, &p, &nonce, &ppkd, &content, &contlen);
if (!buf) {
DEBUGMSG(6, " parsing error or no prefix\n");
goto Done;
}
if (nonce && ccnl_nonce_find_or_append(relay, nonce)) {
DEBUGMSG(6, " dropped because of duplicate nonce\n");
goto Skip;
}
if (buf->data[0] == 0x01 && buf->data[1] == 0xd2) { // interest
DEBUGMSG(1, "ccnl_core_RX_i_or_c: interest=<%s>\n", ccnl_prefix_to_path(p));
from->stat.received_interest++;
if (p->compcnt > 0 && p->comp[0][0] == (unsigned char) 0xc1) {
goto Skip;
}
if (p->compcnt == 4 && !memcmp(p->comp[0], "ccnx", 4)) {
DEBUGMSG(1, "it's a mgnt msg!\n");
rc = ccnl_mgmt(relay, buf, p, from);
DEBUGMSG(1, "mgnt processing done!\n");
goto Done;
}
// CONFORM: Step 1:
if (aok & 0x01) { // honor "answer-from-existing-content-store" flag
for (c = relay->contents; c; c = c->next) {
if (!ccnl_i_prefixof_c(p, ppkd, minsfx, maxsfx, c)) {
continue;
}
// FIXME: should check stale bit in aok here
DEBUGMSG(7, " matching content for interest, content %p\n",
(void *) c);
from->stat.send_content[c->served_cnt % CCNL_MAX_CONTENT_SERVED_STAT]++;
c->served_cnt++;
if (from->ifndx >= 0) {
ccnl_face_enqueue(relay, from, buf_dup(c->pkt));
}
goto Skip;
}
}
// CONFORM: Step 2: check whether interest is already known
for (i = relay->pit; i; i = i->next) {
if (!ccnl_prefix_cmp(i->prefix, NULL, p, CMP_EXACT)
&& i->minsuffix == minsfx && i->maxsuffix == maxsfx
&& ((!ppkd && !i->ppkd) || buf_equal(ppkd, i->ppkd))) {
break;
}
}
if (!i) { // this is a new/unknown I request: create and propagate
i = ccnl_interest_new(relay, from, &buf, &p, minsfx, maxsfx, &ppkd);
if (i) { // CONFORM: Step 3 (and 4)
DEBUGMSG(7, " created new interest entry %p\n", (void *) i);
if (scope > 2) {
ccnl_interest_propagate(relay, i);
}
}
}
else if (scope > 2 && (from->flags & CCNL_FACE_FLAGS_FWDALLI)) {
DEBUGMSG(7, " old interest, nevertheless propagated %p\n",
(void *) i);
ccnl_interest_propagate(relay, i);
}
if (i) { // store the I request, for the incoming face (Step 3)
DEBUGMSG(7, " appending interest entry %p\n", (void *) i);
ccnl_interest_append_pending(i, from);
}
}
else { // content
DEBUGMSG(6, " content=<%s>\n", ccnl_prefix_to_path(p));
from->stat.received_content++;
// CONFORM: Step 1:
for (c = relay->contents; c; c = c->next) {
if (buf_equal(c->pkt, buf)) {
DEBUGMSG(1, "content is dup: skip\n");
goto Skip;
}
}
c = ccnl_content_new(relay, &buf, &p, &ppkd, content, contlen);
if (c) { // CONFORM: Step 2 (and 3)
if (!ccnl_content_serve_pending(relay, c, from)) { // unsolicited content
// CONFORM: "A node MUST NOT forward unsolicited data [...]"
DEBUGMSG(7, " removed because no matching interest\n");
free_content(c);
goto Skip;
}
#if CCNL_DYNAMIC_FIB
else {
/* content has matched an interest, we consider this name as available on this face */
ccnl_content_learn_name_route(relay, c->name, from, relay->fib_threshold_prefix, 0);
}
#endif
if (relay->max_cache_entries != 0) { // it's set to -1 or a limit
DEBUGMSG(7, " adding content to cache\n");
ccnl_content_add2cache(relay, c);
}
else {
DEBUGMSG(7, " content not added to cache\n");
free_content(c);
}
}
}
Skip:
rc = 0;
Done:
free_prefix(p);
free_3ptr_list(buf, nonce, ppkd);
DEBUGMSG(1, "leaving\n");
return rc;
}
BOOL
VDE_IOControl(
DWORD hOpenContext,
DWORD dwCode,
PBYTE pBufIn,
DWORD dwLenIn,
PBYTE pBufOut,
DWORD dwLenOut,
PDWORD pdwActualOut
)
{
SVEngineContext *pCtxt;
BOOL bRet = TRUE;
BYTE LocalBuffer[SVEARG_MAX_SIZE];
PBYTE pBufInLocal = (PBYTE)&LocalBuffer;
pCtxt = SVE_get_context();
DEBUGMSG(VDE_ZONE_ENTER, (_T("[VDE] VDE_IOControl(0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x)\r\n"),
hOpenContext, dwCode, pBufIn, dwLenIn, pBufOut, dwLenOut, pdwActualOut));
memset(pBufInLocal, 0, SVEARG_MAX_SIZE);
if (dwLenIn > SVEARG_MAX_SIZE ||
!CeSafeCopyMemory(pBufInLocal, pBufIn, dwLenIn))
{
RETAILMSG(ZONEMASK_ERROR, (_T("VDE_IOControl: Failed to create a local copy of parameters.\r\n")) );
return FALSE;
}
EnterCriticalSection(&pCtxt->csProc);
switch(dwCode)
{
case IOCTL_POWER_CAPABILITIES:
case IOCTL_POWER_GET:
case IOCTL_POWER_QUERY:
case IOCTL_POWER_SET:
case IOCTL_REGISTER_POWER_RELATIONSHIP:
break;
case IOCTL_SVE_PM_SET_POWER_ON:
SVE_video_engine_power_on();
break;
case IOCTL_SVE_PM_SET_POWER_OFF:
//if caller is not kernel mode, do not allow setting power state to off
if (GetDirectCallerProcessId() != GetCurrentProcessId()){
return FALSE;
}
SVE_video_engine_power_off();
break;
case IOCTL_SVE_RSC_REQUEST_FIMD_INTERFACE:
case IOCTL_SVE_RSC_RELEASE_FIMD_INTERFACE:
case IOCTL_SVE_RSC_REQUEST_FIMD_WIN0:
case IOCTL_SVE_RSC_RELEASE_FIMD_WIN0:
case IOCTL_SVE_RSC_REQUEST_FIMD_WIN1:
case IOCTL_SVE_RSC_RELEASE_FIMD_WIN1:
case IOCTL_SVE_RSC_REQUEST_FIMD_WIN2:
case IOCTL_SVE_RSC_RELEASE_FIMD_WIN2:
case IOCTL_SVE_RSC_REQUEST_FIMD_WIN3:
case IOCTL_SVE_RSC_RELEASE_FIMD_WIN3:
case IOCTL_SVE_RSC_REQUEST_FIMD_WIN4:
case IOCTL_SVE_RSC_RELEASE_FIMD_WIN4:
case IOCTL_SVE_RSC_REQUEST_POST:
case IOCTL_SVE_RSC_RELEASE_POST:
case IOCTL_SVE_RSC_REQUEST_ROTATOR:
case IOCTL_SVE_RSC_RELEASE_ROTATOR:
case IOCTL_SVE_RSC_REQUEST_TVSCALER_TVENCODER:
case IOCTL_SVE_RSC_RELEASE_TVSCALER_TVENCODER:
__try
{
bRet = SVE_Resource_API_Proc(hOpenContext, SVE_get_api_function_code(dwCode), pBufInLocal, dwLenIn, pBufOut, dwLenOut, pdwActualOut);
}
__except ( EXCEPTION_EXECUTE_HANDLER )
{
RETAILMSG( 1, ( _T("VDE_IOControl: exception in IOCTL_SVE_RSC_REQUEST_FIMD_INTERFACE\n")) );
LeaveCriticalSection(&pCtxt->csProc);
return FALSE;
}
break;
case IOCTL_SVE_FIMD_SET_INTERFACE_PARAM:
case IOCTL_SVE_FIMD_SET_OUTPUT_RGBIF:
case IOCTL_SVE_FIMD_SET_OUTPUT_TV:
case IOCTL_SVE_FIMD_SET_OUTPUT_ENABLE:
case IOCTL_SVE_FIMD_SET_OUTPUT_DISABLE:
case IOCTL_SVE_FIMD_SET_WINDOW_MODE:
case IOCTL_SVE_FIMD_SET_WINDOW_POSITION:
case IOCTL_SVE_FIMD_SET_WINDOW_FRAMEBUFFER:
case IOCTL_SVE_FIMD_SET_WINDOW_COLORMAP:
case IOCTL_SVE_FIMD_SET_WINDOW_ENABLE:
case IOCTL_SVE_FIMD_SET_WINDOW_DISABLE:
case IOCTL_SVE_FIMD_SET_WINDOW_BLEND_DISABLE:
case IOCTL_SVE_FIMD_SET_WINDOW_BLEND_COLORKEY:
case IOCTL_SVE_FIMD_SET_WINDOW_BLEND_ALPHA:
case IOCTL_SVE_FIMD_WAIT_FRAME_INTERRUPT:
case IOCTL_SVE_FIMD_GET_OUTPUT_STATUS:
case IOCTL_SVE_FIMD_GET_WINDOW_STATUS:
__try
{
bRet = SVE_DispCon_API_Proc(hOpenContext, SVE_get_api_function_code(dwCode), pBufInLocal, dwLenIn, pBufOut, dwLenOut, pdwActualOut);
}
__except ( EXCEPTION_EXECUTE_HANDLER )
{
RETAILMSG( 1, ( _T("VDE_IOControl: exception in IOCTL_SVE_RSC_REQUEST_FIMD_INTERFACE\n")) );
LeaveCriticalSection(&pCtxt->csProc);
return FALSE;
}
break;
case IOCTL_SVE_POST_SET_PROCESSING_PARAM:
case IOCTL_SVE_POST_SET_SOURCE_BUFFER:
case IOCTL_SVE_POST_SET_NEXT_SOURCE_BUFFER:
case IOCTL_SVE_POST_SET_DESTINATION_BUFFER:
case IOCTL_SVE_POST_SET_NEXT_DESTINATION_BUFFER:
case IOCTL_SVE_POST_SET_PROCESSING_START:
case IOCTL_SVE_POST_SET_PROCESSING_STOP:
case IOCTL_SVE_POST_WAIT_PROCESSING_DONE:
case IOCTL_SVE_POST_GET_PROCESSING_STATUS:
__try
{
bRet = SVE_Post_API_Proc(hOpenContext, SVE_get_api_function_code(dwCode), pBufInLocal, dwLenIn, pBufOut, dwLenOut, pdwActualOut);
}
__except ( EXCEPTION_EXECUTE_HANDLER )
{
RETAILMSG( 1, ( _T("VDE_IOControl: exception in IOCTL_SVE_RSC_REQUEST_FIMD_INTERFACE\n")) );
LeaveCriticalSection(&pCtxt->csProc);
return FALSE;
}
break;
case IOCTL_SVE_LOCALPATH_SET_WIN0_START:
case IOCTL_SVE_LOCALPATH_SET_WIN0_STOP:
case IOCTL_SVE_LOCALPATH_SET_WIN1_START:
case IOCTL_SVE_LOCALPATH_SET_WIN1_STOP:
case IOCTL_SVE_LOCALPATH_SET_WIN2_START:
case IOCTL_SVE_LOCALPATH_SET_WIN2_STOP:
__try
{
bRet = SVE_LocalPath_API_Proc(hOpenContext, SVE_get_api_function_code(dwCode), pBufInLocal, dwLenIn, pBufOut, dwLenOut, pdwActualOut);
}
__except ( EXCEPTION_EXECUTE_HANDLER )
{
RETAILMSG( 1, ( _T("VDE_IOControl: exception in IOCTL_SVE_RSC_REQUEST_FIMD_INTERFACE\n")) );
LeaveCriticalSection(&pCtxt->csProc);
return FALSE;
}
break;
case IOCTL_SVE_ROTATOR_SET_OPERATION_PARAM:
case IOCTL_SVE_ROTATOR_SET_SOURCE_BUFFER:
case IOCTL_SVE_ROTATOR_SET_DESTINATION_BUFFER:
case IOCTL_SVE_ROTATOR_SET_OPERATION_START:
case IOCTL_SVE_ROTATOR_SET_OPERATION_STOP:
case IOCTL_SVE_ROTATOR_WAIT_OPERATION_DONE:
case IOCTL_SVE_ROTATOR_GET_STATUS:
__try
{
bRet = SVE_Rotator_API_Proc(hOpenContext, SVE_get_api_function_code(dwCode), pBufInLocal, dwLenIn, pBufOut, dwLenOut, pdwActualOut);
}
__except ( EXCEPTION_EXECUTE_HANDLER )
{
RETAILMSG( 1, ( _T("VDE_IOControl: exception in IOCTL_SVE_RSC_REQUEST_FIMD_INTERFACE\n")) );
LeaveCriticalSection(&pCtxt->csProc);
return FALSE;
}
break;
case IOCTL_SVE_TVSC_SET_PROCESSING_PARAM:
case IOCTL_SVE_TVSC_SET_SOURCE_BUFFER:
case IOCTL_SVE_TVSC_SET_NEXT_SOURCE_BUFFER:
case IOCTL_SVE_TVSC_SET_DESTINATION_BUFFER:
case IOCTL_SVE_TVSC_SET_NEXT_DESTINATION_BUFFER:
case IOCTL_SVE_TVSC_SET_PROCESSING_START:
case IOCTL_SVE_TVSC_SET_PROCESSING_STOP:
case IOCTL_SVE_TVSC_WAIT_PROCESSING_DONE:
case IOCTL_SVE_TVSC_GET_PROCESSING_STATUS:
__try
{
bRet = SVE_TVScaler_API_Proc(hOpenContext, SVE_get_api_function_code(dwCode), pBufInLocal, dwLenIn, pBufOut, dwLenOut, pdwActualOut);
}
__except ( EXCEPTION_EXECUTE_HANDLER )
{
RETAILMSG( 1, ( _T("VDE_IOControl: exception in IOCTL_SVE_RSC_REQUEST_FIMD_INTERFACE\n")) );
LeaveCriticalSection(&pCtxt->csProc);
return FALSE;
}
break;
case IOCTL_SVE_TVENC_SET_INTERFACE_PARAM:
case IOCTL_SVE_TVENC_SET_ENCODER_ON:
case IOCTL_SVE_TVENC_SET_ENCODER_OFF:
case IOCTL_SVE_TVENC_GET_INTERFACE_STATUS:
__try
{
bRet = SVE_TVEncoder_API_Proc(hOpenContext, SVE_get_api_function_code(dwCode), pBufInLocal, dwLenIn, pBufOut, dwLenOut, pdwActualOut);
}
__except ( EXCEPTION_EXECUTE_HANDLER )
{
RETAILMSG( 1, ( _T("VDE_IOControl: exception in IOCTL_SVE_RSC_REQUEST_FIMD_INTERFACE\n")) );
LeaveCriticalSection(&pCtxt->csProc);
return FALSE;
}
break;
case IOCTL_SVE_FIMD_VSYNC_ENABLE:
__try
{
Disp_VSync_Enable();
bRet=TRUE;
}
__except ( EXCEPTION_EXECUTE_HANDLER )
{
RETAILMSG( 1, ( _T("VDE_IOControl: exception in IOCTL_SVE_FIMD_VSYNC_ENABLE\n")) );
LeaveCriticalSection(&pCtxt->csProc);
return FALSE;
}
break;
case IOCTL_SVE_FIMD_GET_FLIPSTATUS:
__try
{
if(Disp_GetFlipStatus())
{
bRet=TRUE;
}
else
{
bRet=FALSE;
}
}
__except ( EXCEPTION_EXECUTE_HANDLER )
{
RETAILMSG( 1, ( _T("VDE_IOControl: exception in IOCTL_SVE_FIMD_GET_FLIPSTATUS\n")) );
LeaveCriticalSection(&pCtxt->csProc);
return FALSE;
}
break;
case IOCTL_SVE_PM_GET_POWER_STATUS:
default:
VDE_ERR((_T("[VDE:ERR] VDE_IOControl() : Unknown IOCTL [0x%08x]\r\n"), dwCode));
SetLastError (ERROR_INVALID_ACCESS);
bRet = FALSE;
break;
}
LeaveCriticalSection(&pCtxt->csProc);
DEBUGMSG(VDE_ZONE_ENTER, (_T("[VDE] --VDE_IOControl()\r\n")));
return bRet;
}
BOOL SDC_Close(DWORD hOpenContext)
{
DEBUGMSG(SDCARD_ZONE_FUNC, (TEXT("SDBusDriver: +-SDC_Close\n")));
return TRUE;
}
/*
* Extraction d'une nouvelle page de la requête
* Exact a new job page
*/
Page* Document::getNextRawPage(const Request& request)
{
cups_page_header_t header;
unsigned long pageWidth, pageWidthInB, pageHeight, clippingX=0, clippingY=0;
unsigned long documentWidth, documentHeight, lineSize, planeSize, index=0;
unsigned long bytesToCopy, marginWidthInB=0, marginHeight=0;
unsigned char *line, *planes[4];
unsigned char colors;
Page *page;
// Read the header
if (_lastPage)
return NULL;
if (!_raster) {
ERRORMSG(_("The raster hasn't been loaded"));
return NULL;
}
if (!cupsRasterReadHeader(_raster, &header) || !header.cupsBytesPerLine ||
!header.PageSize[1]) {
DEBUGMSG(_("No more pages"));
_lastPage = true;
return NULL;
}
// Make some calculations and store important data
page = new Page;
page->setXResolution(header.HWResolution[0]);
page->setYResolution(header.HWResolution[1]);
colors = header.cupsColorSpace == CUPS_CSPACE_K ? 1 : 4;
documentWidth = (header.cupsWidth + 7) & ~7;
documentHeight = header.cupsHeight;
lineSize = header.cupsBytesPerLine / colors;
pageWidth = ((unsigned long)ceil(page->convertToXResolution(request.
printer()->pageWidth())) + 7) & ~7;
pageHeight = ceil(page->convertToYResolution(request.printer()->
pageHeight()));
marginWidthInB =(ceil(page->convertToXResolution(header.Margins[0]))+7)/8;
marginHeight = ceil(page->convertToYResolution(header.Margins[1]));
pageWidthInB = (pageWidth + 7) / 8;
planeSize = pageWidthInB * pageHeight;
page->setWidth(pageWidth);
page->setHeight(pageHeight);
page->setColorsNr(colors);
page->setPageNr(_currentPage);
page->setCompression(header.cupsCompression);
page->setCopiesNr(header.NumCopies);
// Calculate clippings and margins
if (lineSize > pageWidthInB - 2 * marginWidthInB) {
clippingX = (lineSize - (pageWidthInB - 2 * marginWidthInB)) / 2;
bytesToCopy = pageWidthInB - 2 * marginWidthInB;
} else {
clippingX = 0;
marginWidthInB = (pageWidthInB - lineSize) / 2;
bytesToCopy = lineSize;
}
if (documentHeight > pageHeight - 2 * marginHeight) {
clippingY = (documentHeight - (pageHeight - 2 * marginHeight)) / 2;
index = pageWidthInB * marginHeight;
} else {
clippingY = 0;
index = pageWidthInB * ((pageHeight - documentHeight)/2);
}
documentHeight -= clippingY;
pageHeight -= 2*marginHeight;
clippingY *= colors;
line = new unsigned char[header.cupsBytesPerLine];
DEBUGMSG(_("Document width=%lu height=%lu"), documentWidth, documentHeight);
DEBUGMSG(_("Page width=%lu (%lu) height=%lu"), pageWidth, pageWidthInB, pageHeight);
DEBUGMSG(_("Margin width in bytes=%lu height=%lu"), marginWidthInB, marginHeight);
DEBUGMSG(_("Clipping X=%lu Y=%lu"), clippingX, clippingY);
DEBUGMSG(_("Line size=%lu, Plane size=%lu, bytes to copy=%lu"), lineSize, planeSize, bytesToCopy);
// Prepare planes and clip vertically the document if needed
for (unsigned char i=0; i < colors; i++) {
planes[i] = new unsigned char[planeSize];
memset(planes[i], 0, planeSize);
}
while (clippingY) {
if (cupsRasterReadPixels(_raster, line, lineSize) < 1) {
ERRORMSG(_("Cannot read pixel line"));
for (unsigned int i=0; i < colors; i++)
delete[] planes[i];
delete[] line;
delete page;
return NULL;
}
clippingY--;
}
// Load the bitmap
while (pageHeight && documentHeight) {
for (unsigned int i=0; i < colors; i++) {
if (cupsRasterReadPixels(_raster, line, lineSize) < 1) {
ERRORMSG(_("Cannot read pixel line"));
for (unsigned int j=0; j < colors; j++)
delete[] planes[j];
delete[] line;
delete page;
return NULL;
}
memcpy(planes[i] + index + marginWidthInB, line + clippingX,
bytesToCopy);
}
index += pageWidthInB;
pageHeight--;
documentHeight--;
}
// Finish to clip vertically the document
documentHeight *= colors;
while (documentHeight) {
if (cupsRasterReadPixels(_raster, line, lineSize) < 1) {
ERRORMSG(_("Cannot read pixel line"));
for (unsigned int j=0; j < colors; j++)
delete[] planes[j];
delete[] line;
delete page;
return NULL;
}
documentHeight--;
}
_currentPage++;
for (unsigned int i=0; i < colors; i++)
page->setPlaneBuffer(i, planes[i]);
DEBUGMSG(_("Page %lu (%u×%u on %lu×%lu) has been successfully loaded into "
"memory"), page->pageNr(), header.cupsWidth, header.cupsHeight,
page->width(), page->height());
delete[] line;
return page;
}
/**
* \author Dave Sheppard (DS)
* \author Darryn Campbell (DCC, JRQ768)
* \date March 2005 (First Created, DS)
* \date November 2009 (Converted from static to non-static.)
*/
void CSIP::InitSIP()
{
l_bEscape = FALSE;
m_bSipControl = false;
m_bAllowSIP = true;
m_bSIPOn = false;
m_bTitleShown = false;
//reset the key state to unshifted
hKeybdDriver = LoadLibrary(KEYBOARD_DLL);
pfnSetKeyState = NULL;
if (hKeybdDriver)
{
pfnSetKeyState = (LPFNSETKEYSTATE)GetProcAddress(hKeybdDriver, SETKEYSTATE);
if (pfnSetKeyState)
{
//pfnSetKeyState(UN_SHIFTED, 0, true);
}
}
// Find the SIP window
hSipWnd = FindWindow(L"SipWndClass", NULL);
if (hSipWnd) {
// Find and store the original position
GetWindowRect(hSipWnd, &m_rcOriginalPos);
m_rcPosition = m_rcOriginalPos;
// Get the style
m_dwOriginalStyle = GetWindowLong(hSipWnd, GWL_STYLE);
// DCC (16/06/2012) Removing the SIP caption is not compatible with
// CE7, it gives undesired results, specifically when resizing the SIP
// following removal of the caption and also moving the SIP where the
// task bar used to be is a bad idea. This seems unrelated to debug
// buttons (as previously observed with other OS') and is particularly
// evident when toggling the SIP. Conceivably this could be made a config
// option if required, I know the Nano team were asking for this at one point.
OSVERSIONINFO osvi;
memset(&osvi, 0, sizeof(OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&osvi);
bool bIsCE7 = (osvi.dwMajorVersion == 7);
if (!bIsCE7)
{
if (m_dwOriginalStyle & WS_CAPTION) {
m_bTitleShown = true;
// It has a caption bar so must be CE .NET
// Now see if its a big one
m_rcPosition.top += 26; // Move the SIP down by the CAPTION size
if (m_rcOriginalPos.right - m_rcOriginalPos.left > 242)
m_rcPosition.bottom = m_rcPosition.top+194;
else
m_rcPosition.bottom = m_rcPosition.top+80;
LONG lStyle = m_dwOriginalStyle ^ WS_CAPTION;
SetWindowLong(hSipWnd, GWL_STYLE, lStyle); // Remove the CAPTION
}
//else m_rcPosition.bottom++; // Else its WM2003 so add one line of pixels to the bottom
}
else
DEBUGMSG(true, (L"Device is CE7, not hiding SIP caption"));
// Put the Window in the correct place at the correct size
MoveWindow(hSipWnd, m_rcPosition.left, m_rcPosition.top, m_rcPosition.right-m_rcPosition.left, m_rcPosition.bottom-m_rcPosition.top, TRUE);
}
m_bSipControl = RetrieveSIPControlConfigValue(hSipWnd);
}
void
mte_add_objects(netsnmp_variable_list * vars,
struct mteTriggerTable_data *item, const char *owner,
const char *name, oid * suffix, size_t suffix_len)
{
struct header_complex_index *hcptr = mteObjectsTableStorage;
DEBUGMSGTL(("mteObjectsTable",
"Searching for objects to add for owner=%s / name=%s\n",
owner, name));
if (vars == NULL || item == NULL || owner == NULL || name == NULL ||
hcptr == NULL)
return;
/*
* get to end of variable chain
*/
while (vars->next_variable != NULL)
vars = vars->next_variable;
/*
* get to start of objects list
*/
while (hcptr &&
(strcmp(((struct mteObjectsTable_data *) hcptr->data)->mteOwner,
owner) != 0 ||
strcmp(((struct mteObjectsTable_data *) hcptr->data)->
mteObjectsName, name) != 0))
hcptr = hcptr->next;
/*
* add all objects
*/
while (hcptr &&
strcmp(((struct mteObjectsTable_data *) hcptr->data)->mteOwner,
owner) == 0 &&
strcmp(((struct mteObjectsTable_data *) hcptr->data)->
mteObjectsName, name) == 0) {
/*
* loop through objects
*/
netsnmp_pdu *pdu = NULL, *response = NULL;
struct mteObjectsTable_data *node =
(struct mteObjectsTable_data *) hcptr->data;
oid theoid[MAX_OID_LEN];
size_t theoid_len;
/*
* copy in the suffix
*/
memcpy(theoid, node->mteObjectsID,
node->mteObjectsIDLen * sizeof(oid));
theoid_len = node->mteObjectsIDLen;
if (node->mteObjectsIDWildcard == MTEOBJECTSIDWILDCARD_TRUE &&
suffix && suffix_len > 0) {
theoid_len += suffix_len;
if (theoid_len > MAX_OID_LEN) {
break; /* XXX: properly send trap or something? */
}
memcpy(&theoid[node->mteObjectsIDLen], suffix,
suffix_len * sizeof(oid));
}
/*
* retrieve the value
*/
pdu = snmp_pdu_create(SNMP_MSG_GET);
snmp_add_null_var(pdu, theoid, theoid_len);
response = mte_get_response(item, pdu);
if (response) {
if (vars) {
vars->next_variable = response->variables;
vars = vars->next_variable;
DEBUGMSGTL(("mteObjectsTable", "Adding: "));
DEBUGMSGOID(("mteObjectsTable", response->variables->name,
response->variables->name_length));
DEBUGMSG(("mteObjectsTable", "\n"));
} else {
vars = response->variables;
}
/*
* erase response notion of the values we stole from it
*/
response->variables = NULL;
snmp_free_pdu(response);
}
/*
* move along
*/
hcptr = hcptr->next;
}
DEBUGMSGTL(("mteObjectsTable", "Done adding objects\n"));
}
