/* This function will make sure that tilda window becomes active (gains
* the focus) when it is called.
*
* This has to be the worst possible way of making this work, but it was the
* only way to get metacity to play nicely. All the other WM's are so nice,
* why oh why does metacity hate us so?
*/
void tilda_window_set_active (tilda_window *tw)
{
DEBUG_FUNCTION ("tilda_window_set_active");
DEBUG_ASSERT (tw != NULL);
Display *x11_display = GDK_WINDOW_XDISPLAY (gtk_widget_get_window (tw->window) );
Window x11_window = GDK_WINDOW_XID (gtk_widget_get_window (tw->window) );
Window x11_root_window = GDK_WINDOW_XID ( gtk_widget_get_root_window (tw->window) );
GdkScreen *screen = gtk_widget_get_screen (tw->window);
XEvent event;
long mask = SubstructureRedirectMask | SubstructureNotifyMask;
gtk_window_move (GTK_WINDOW(tw->window), config_getint ("x_pos"), config_getint ("y_pos"));
if (gdk_x11_screen_supports_net_wm_hint (screen,
gdk_atom_intern_static_string ("_NET_ACTIVE_WINDOW")))
{
guint32 timestamp = gtk_get_current_event_time ();
if (timestamp == 0) {
timestamp = gdk_x11_get_server_time(gdk_screen_get_root_window (screen));
}
event.xclient.type = ClientMessage;
event.xclient.serial = 0;
event.xclient.send_event = True;
event.xclient.display = x11_display;
event.xclient.window = x11_window;
event.xclient.message_type = gdk_x11_get_xatom_by_name ("_NET_ACTIVE_WINDOW");
event.xclient.format = 32;
event.xclient.data.l[0] = 2; /* pager */
event.xclient.data.l[1] = timestamp; /* timestamp */
event.xclient.data.l[2] = 0;
event.xclient.data.l[3] = 0;
event.xclient.data.l[4] = 0;
XSendEvent (x11_display, x11_root_window, False, mask, &event);
}
else
{
/* The WM doesn't support the EWMH standards. We'll print a warning and
* try this, though it probably won't work... */
g_printerr (_("WARNING: Window manager (%s) does not support EWMH hints\n"),
gdk_x11_screen_get_window_manager_name (screen));
XRaiseWindow (x11_display, x11_window);
}
}
/*
* This function is called to "start up" the interface. It may be called
* multiple times, even when the hardware is already running. It will be
* called whenever something "hardware oriented" changes and should leave
* the hardware ready to send/receive packets.
*/
static void
dp83902a_start(u8 * enaddr)
{
dp83902a_priv_data_t *dp = &nic;
u8 *base = dp->base;
int i;
debug("The MAC is %pM\n", enaddr);
DEBUG_FUNCTION();
DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_STOP); /* Brutal */
DP_OUT(base, DP_DCR, DP_DCR_INIT);
DP_OUT(base, DP_RBCH, 0); /* Remote byte count */
DP_OUT(base, DP_RBCL, 0);
DP_OUT(base, DP_RCR, DP_RCR_MON); /* Accept no packets */
DP_OUT(base, DP_TCR, DP_TCR_LOCAL); /* Transmitter [virtually] off */
DP_OUT(base, DP_TPSR, dp->tx_buf1); /* Transmitter start page */
dp->tx1 = dp->tx2 = 0;
dp->tx_next = dp->tx_buf1;
dp->tx_started = false;
dp->running = true;
DP_OUT(base, DP_PSTART, dp->rx_buf_start); /* Receive ring start page */
DP_OUT(base, DP_BNDRY, dp->rx_buf_end - 1); /* Receive ring boundary */
DP_OUT(base, DP_PSTOP, dp->rx_buf_end); /* Receive ring end page */
dp->rx_next = dp->rx_buf_start - 1;
dp->running = true;
DP_OUT(base, DP_ISR, 0xFF); /* Clear any pending interrupts */
DP_OUT(base, DP_IMR, DP_IMR_All); /* Enable all interrupts */
DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE1 | DP_CR_STOP); /* Select page 1 */
DP_OUT(base, DP_P1_CURP, dp->rx_buf_start); /* Current page - next free page for Rx */
dp->running = true;
for (i = 0; i < ETHER_ADDR_LEN; i++) {
/* FIXME */
/*((vu_short*)( base + ((DP_P1_PAR0 + i) * 2) +
* 0x1400)) = enaddr[i];*/
DP_OUT(base, DP_P1_PAR0+i, enaddr[i]);
}
/* Enable and start device */
DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
DP_OUT(base, DP_TCR, DP_TCR_NORMAL); /* Normal transmit operations */
DP_OUT(base, DP_RCR, DP_RCR_AB); /* Accept broadcast, no errors, no multicast */
dp->running = true;
}
/*
* Compares two config versions together.
*
* Returns -1 if config1 is older than config2 (UPDATE REQUIRED)
* Returns 0 if config1 is equal to config2 (NORMAL USAGE)
* Returns 1 if config1 is newer than config2 (DISABLE WRITE)
*/
static gboolean compare_config_versions (const gchar *config1, const gchar *config2)
{
DEBUG_FUNCTION ("compare_config_versions");
DEBUG_ASSERT (config1 != NULL);
DEBUG_ASSERT (config2 != NULL);
/*
* 1) Split apart both strings using the .'s
* 2) Compare the major-major version
* 3) Compare the major version
* 4) Compare the minor version
*/
gchar **config1_tokens;
gchar **config2_tokens;
gint config1_version[3];
gint config2_version[3];
gint i;
config1_tokens = g_strsplit (config1, ".", 3);
config2_tokens = g_strsplit (config2, ".", 3);
for (i=0; i<3; i++)
{
config1_version[i] = atoi (config1_tokens[i]);
config2_version[i] = atoi (config2_tokens[i]);
}
g_strfreev (config1_tokens);
g_strfreev (config2_tokens);
/* We're done splitting things, so compare now */
for (i=0; i<3; i++)
{
if (config1_version[i] > config2_version[i])
return CONFIG1_NEWER;
if (config1_version[i] < config2_version[i])
return CONFIG1_OLDER;
}
return CONFIGS_SAME;
}
static void refresh_window_cb (G_GNUC_UNUSED GtkWidget *widget, gpointer data)
{
DEBUG_FUNCTION ("refresh_window_cb");
DEBUG_ASSERT (data != NULL);
GdkRectangle rect;
if (GTK_IS_WIDGET(data))
{
if (gtk_widget_get_window (GTK_WIDGET (data)))
{
rect.x = rect.y = 0;
GtkAllocation allocation;
gtk_widget_get_allocation (GTK_WIDGET (data), &allocation);
rect.width = allocation.width;
rect.height = allocation.height;
gdk_window_invalidate_rect (gtk_widget_get_window (GTK_WIDGET(data)), &rect, TRUE);
}
}
}
/**
* This function reads the MAC address from the serial EEPROM,
* used if PROM read fails. Does nothing for ax88796 chips (sh boards)
*/
static bool
dp83902a_init(unsigned char *enetaddr)
{
dp83902a_priv_data_t *dp = &nic;
u8* base;
#if defined(NE2000_BASIC_INIT)
int i;
#endif
DEBUG_FUNCTION();
base = dp->base;
if (!base)
return false; /* No device found */
DEBUG_LINE();
#if defined(NE2000_BASIC_INIT)
/* AX88796L doesn't need */
/* Prepare ESA */
DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE1); /* Select page 1 */
/* Use the address from the serial EEPROM */
for (i = 0; i < 6; i++)
DP_IN(base, DP_P1_PAR0+i, dp->esa[i]);
DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE0); /* Select page 0 */
printf("NE2000 - %s ESA: %02x:%02x:%02x:%02x:%02x:%02x\n",
"eeprom",
dp->esa[0],
dp->esa[1],
dp->esa[2],
dp->esa[3],
dp->esa[4],
dp->esa[5] );
memcpy(enetaddr, dp->esa, 6); /* Use MAC from serial EEPROM */
#endif /* NE2000_BASIC_INIT */
return true;
}
gint xerror_handler(Display *d, XErrorEvent *e)
{
DEBUG_FUNCTION ("xerror_handler");
xerror_occurred = TRUE;
#ifdef DEBUG
if (!xerror_ignore) {
gchar errtxt[128];
/*if (e->error_code != BadWindow) */
{
XGetErrorText(d, e->error_code, errtxt, 127);
if (e->error_code == BadWindow)
/*g_warning("X Error: %s", errtxt)*/;
else
g_error(_("X Error: %s"), errtxt);
}
}
#else
(void)d; (void)e;
#endif
return 0;
}
static void
dp83902a_start_xmit(int start_page, int len)
{
dp83902a_priv_data_t *dp = (dp83902a_priv_data_t *) &nic;
cyg_uint8 *base = dp->base;
DEBUG_FUNCTION();
#if DEBUG & 1
printf("Tx pkt %d len %d\n", start_page, len);
if (dp->tx_started)
printf("TX already started?!?\n");
#endif
DP_OUT(base, DP_ISR, (DP_ISR_TxP | DP_ISR_TxE));
DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
DP_OUT(base, DP_TBCL, len & 0xFF);
DP_OUT(base, DP_TBCH, len >> 8);
DP_OUT(base, DP_TPSR, start_page);
DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_TXPKT | DP_CR_START);
dp->tx_started = true;
}
static void child_exited_cb (GtkWidget *widget, gpointer data)
{
DEBUG_FUNCTION ("child_exited_cb");
DEBUG_ASSERT (widget != NULL);
DEBUG_ASSERT (data != NULL);
tilda_term *tt = TILDA_TERM(data);
gint index = gtk_notebook_page_num (GTK_NOTEBOOK(tt->tw->notebook), tt->hbox);
/* Make sure we got a valid index */
if (index == -1)
{
DEBUG_ERROR ("Bad notebook tab\n");
return;
}
/* These can stay here. They don't need to go into a header because
* they are only used at this point in the code. */
enum command_exit { DROP_TO_DEFAULT_SHELL, RESTART_COMMAND, EXIT_TERMINAL };
/* Check the user's preference for what to do when the child terminal
* is closed. Take the appropriate action */
switch (config_getint ("command_exit"))
{
case EXIT_TERMINAL:
tilda_window_close_tab (tt->tw, index, FALSE);
break;
case RESTART_COMMAND:
vte_terminal_feed (VTE_TERMINAL(tt->vte_term), "\r\n\r\n", 4);
start_shell (tt, FALSE, NULL);
break;
case DROP_TO_DEFAULT_SHELL:
start_shell (tt, TRUE, NULL);
default:
break;
}
}
static void window_title_changed_cb (GtkWidget *widget, gpointer data)
{
DEBUG_FUNCTION ("window_title_changed_cb");
DEBUG_ASSERT (widget != NULL);
DEBUG_ASSERT (data != NULL);
tilda_term *tt = TILDA_TERM(data);
gchar *title = get_window_title (widget);
GtkWidget *label;
label = gtk_notebook_get_tab_label (GTK_NOTEBOOK (tt->tw->notebook), tt->hbox);
/* We need to check if the widget that received the title change is the currently
* active tab. If not we should not update the window title. */
gint page = gtk_notebook_get_current_page (GTK_NOTEBOOK (tt->tw->notebook));
GtkWidget *active_page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (tt->tw->notebook), page);
gboolean active = widget == active_page;
guint length = (guint) config_getint ("title_max_length");
if(config_getbool("title_max_length_flag") && strlen(title) > length) {
gchar *titleOffset = title + strlen(title) - length;
gchar *shortTitle = g_strdup_printf ("...%s", titleOffset);
gtk_label_set_text (GTK_LABEL(label), shortTitle);
if (active) {
gtk_window_set_title (GTK_WINDOW (tt->tw->window), shortTitle);
}
g_free(shortTitle);
} else {
gtk_label_set_text (GTK_LABEL(label), title);
if (active) {
gtk_window_set_title (GTK_WINDOW (tt->tw->window), title);
}
}
g_free (title);
}
void tilda_term_set_scrollbar_position (tilda_term *tt, enum tilda_term_scrollbar_positions pos)
{
DEBUG_FUNCTION ("tilda_term_set_scrollbar_position");
DEBUG_ASSERT (tt != NULL);
DEBUG_ASSERT (pos == LEFT || pos == RIGHT || pos == DISABLED);
switch (pos)
{
case LEFT:
gtk_box_reorder_child (GTK_BOX(tt->hbox), tt->scrollbar, 0);
gtk_widget_show (tt->scrollbar);
break;
case RIGHT:
gtk_box_reorder_child (GTK_BOX(tt->hbox), tt->scrollbar, 1);
gtk_widget_show (tt->scrollbar);
break;
case DISABLED:
default:
gtk_widget_hide (tt->scrollbar);
break;
}
}
static void adjust_font_size (GtkWidget *widget, gpointer data, gint howmuch)
{
DEBUG_FUNCTION ("adjust_font_size");
DEBUG_ASSERT (widget != NULL);
DEBUG_ASSERT (data != NULL);
VteTerminal *terminal;
PangoFontDescription *desired;
gint newsize;
gint columns, rows, owidth, oheight;
/* Read the screen dimensions in cells. */
terminal = VTE_TERMINAL(widget);
columns = vte_terminal_get_column_count (terminal);
rows = vte_terminal_get_row_count (terminal);
/* Take into account padding and border overhead. */
gtk_window_get_size(GTK_WINDOW(data), &owidth, &oheight);
owidth -= vte_terminal_get_char_width (terminal) * columns;
oheight -= vte_terminal_get_char_height (terminal) * rows;
/* Calculate the new font size. */
desired = pango_font_description_copy (vte_terminal_get_font(terminal));
newsize = pango_font_description_get_size (desired) / PANGO_SCALE;
newsize += howmuch;
pango_font_description_set_size (desired, CLAMP(newsize, 4, 144) * PANGO_SCALE);
/* Change the font, then resize the window so that we have the same
* number of rows and columns. */
vte_terminal_set_font (terminal, desired);
/*gtk_window_resize (GTK_WINDOW(data),
columns * terminal->char_width + owidth,
rows * terminal->char_height + oheight);*/
pango_font_description_free (desired);
}
Message* AppNSHandlerImpl::InvokeImpl(LWPR::SOCKET_FD_T fd, const TUX_HEADER_MESSAGE_T& req_header, LWPR::InputStream& req_body)
{
DEBUG_FUNCTION();
Message* pMsgRep = NULL;
try
{
switch(req_header.nMsgType)
{
case TUX_MSG_TYPE_PING_PANG_REQ:
{
// 解析请求报文
TUX_APP_PINGPANG_REQ_T msgReq;
msgReq.Unmarshal(req_body);
msgReq.MsgHeader(req_header);
// 创建应答报文
TUX_APP_PINGPANG_REP_T* pMsgRepCurrent = new TUX_APP_PINGPANG_REP_T();
pMsgRep = pMsgRepCurrent;
// 业务逻辑实现
pMsgRepCurrent->MsgHeader().nMsgRetCode = TUX_MSG_RET_CODE_OK;
}
break;
case TUX_MSG_TYPE_TPCALL_REQ:
{
// 解析请求报文
TUX_APP_TPCALL_REQ_T msgReq;
msgReq.Unmarshal(req_body);
msgReq.MsgHeader(req_header);
// 创建应答报文
TUX_APP_TPCALL_REP_T* pMsgRepCurrent = new TUX_APP_TPCALL_REP_T();
pMsgRep = pMsgRepCurrent;
// 业务逻辑实现
CallService(fd, msgReq, *pMsgRepCurrent);
}
break;
default:
break;
}
}
catch(const LWPR::Exception& e)
{
logger->error(LTRACE, "%s", e.what());
delete pMsgRep;
pMsgRep = NULL;
}
catch(...)
{
logger->error(LTRACE, "Unknow Exception");
delete pMsgRep;
pMsgRep = NULL;
}
if(pMsgRep)
{
pMsgRep->MsgHeader().DisconnectFromServer(GetNetServer()->ClientTotal() > AppConfig::GetInstance()->TUXONE_APP_SERVER_MAXLONGCONNECTIONS());
}
return pMsgRep;
}
void AppNSHandlerImpl::DoThreadEnd()
{
DEBUG_FUNCTION();
tpsvrthrdone();
}
void AppNSHandlerImpl::DoClientAmountUpdate(int amount, LWPR::SOCKET_FD_T fd, bool increase)
{
DEBUG_FUNCTION();
}
LWPR::SOCKET_RET_TYPE_E AppNSHandlerImpl::DoCloseExpiredSocket(LWPR::SOCKET_FD_T fd)
{
DEBUG_FUNCTION();
return LWPR::SOCKET_RET_OK;
}
AppNSHandlerImpl::~AppNSHandlerImpl()
{
DEBUG_FUNCTION();
delete[] m_argv;
}
void AppNSHandlerImpl::ExecuteServiceMethod(TPSVCINFO* rqst, SVCFUNC_FP fp, TUX_APP_TPCALL_REQ_T& request, TUX_APP_TPCALL_REP_T& response)
{
DEBUG_FUNCTION();
assert(rqst != NULL);
assert(fp != NULL);
response.MsgHeader().nMsgRetCode = TUX_MSG_RET_CODE_SVC_ERR;
// 保留函数返回点
int code = sigsetjmp(TLSLibtux::GetInstance()->GetJmpBuf(), 1);
// 返回值为0表示从sigsetjmp返回，其他值表示从siglongjmp返回
if(code == 0)
{
logger->debug(LTRACE, "Invoke user service function");
// 执行用户service函数
fp(rqst);
}
else
{
TPRETURN_INFO_T& info = TLSLibtux::GetInstance()->GetTpreturnInfo();
response.nFlags = info.flags;
response.pRepBuf = info.data;
response.nRepLen = info.len;
response.nRetCode = info.rcode;
response.bHasRep = (response.pRepBuf != NULL);
switch(info.rval)
{
case TPSUCCESS:
{
response.MsgHeader().nMsgRetCode = TUX_MSG_RET_CODE_OK;
// 获取应答数据类型
if(!ATMIBufferManager::GetInstance()->GetBufferTypes((char *)response.pRepBuf, response.nRepBufType, response.strRepBufTypeSub))
{
response.nRepBufType = TYPED_BUFFER_CARRAY;
}
if(response.bHasRep)
{
// 如果应答buf与请求buf是同一个buf
if(request.vReqBuf->Inout() == response.pRepBuf)
{
// 仅仅为了持有一份引用
response.vRepBuf = request.vReqBuf;
// 应答Buffer的数据保持同请求数据一致
response.nRepBufType = request.nReqBufType;
response.strRepBufTypeSub = request.strReqBufTypeSub;
}
// 如果是VIEW32类型，需要附加结构体信息
if(TYPED_BUFFER_VIEW32 == response.nRepBufType)
{
if(!View32Manager::GetInstance()->GetStructInfo(response.strRepBufTypeSub.c_str(), response.tStructInfo))
{
response.MsgHeader().nMsgRetCode = TUX_MSG_RET_CODE_SVC_ERR;
return;
}
response.nRepLen = response.tStructInfo.structSize;
}
// 如果是FML32类型，需要调整应答数据长度及字节序
else if(TYPED_BUFFER_FML32 == response.nRepBufType)
{
response.nRepLen = FMLValidSize((FBFR32 *)response.pRepBuf);
FMLHeaderToNet(response.pRepBuf);
}
// 如果是STRING类型，需要调整应答数据长度
else if(TYPED_BUFFER_STRING == response.nRepBufType)
{
response.nRepLen = strlen(response.pRepBuf);
}
}
// 处理应答数据
switch(response.nRepBufType)
{
case TYPED_BUFFER_CARRAY:
break;
case TYPED_BUFFER_STRING:
break;
case TYPED_BUFFER_MBSTRING:
break;
case TYPED_BUFFER_VIEW32:
break;
case TYPED_BUFFER_FML32:
break;
case TYPED_BUFFER_XML:
break;
default:
response.MsgHeader().nMsgRetCode = TUX_MSG_RET_CODE_SVC_ERR;
break;
}
}
break;
case TPFAIL:
{
response.MsgHeader().nMsgRetCode = TUX_MSG_RET_CODE_SVC_FAIL;
}
break;
case TPEXIT:
{
response.MsgHeader().nMsgRetCode = TUX_MSG_RET_CODE_SVC_ERR;
exit(0);
}
break;
default:
response.MsgHeader().nMsgRetCode = TUX_MSG_RET_CODE_SVC_ERR;
break;
}
}
}
static void onKeybindingPull (G_GNUC_UNUSED const char *keystring, gpointer user_data)
{
DEBUG_FUNCTION("onKeybindingPull");
tilda_window *tw = TILDA_WINDOW(user_data);
pull (tw, PULL_TOGGLE, FALSE);
}
/*
This function is called as a result of the "eth_drv_recv()" call above.
It's job is to actually fetch data for a packet from the hardware once
memory buffers have been allocated for the packet. Note that the buffers
may come in pieces, using a scatter-gather list. This allows for more
efficient processing in the upper layers of the stack.
*/
static void
dp83902a_recv(unsigned char *data, int len)
{
struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
cyg_uint8 *base = dp->base;
int i, mlen;
cyg_uint8 saved_char = 0;
bool saved;
#if DEBUG & 4
int dx;
#endif
DEBUG_FUNCTION();
#if DEBUG & 5
printf("Rx packet %d length %d\n", dp->rx_next, len);
#endif
/* Read incoming packet data */
DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
DP_OUT(base, DP_RBCL, len & 0xFF);
DP_OUT(base, DP_RBCH, len >> 8);
DP_OUT(base, DP_RSAL, 4); /* Past header */
DP_OUT(base, DP_RSAH, dp->rx_next);
DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
DP_OUT(base, DP_CR, DP_CR_RDMA | DP_CR_START);
#ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_RX_DMA
CYGACC_CALL_IF_DELAY_US(10);
#endif
saved = false;
for (i = 0; i < 1; i++) {
if (data) {
mlen = len;
#if DEBUG & 4
printf(" sg buf %08lx len %08x \n", (unsigned long) data, mlen);
dx = 0;
#endif
while (0 < mlen) {
/* Saved byte from previous loop? */
if (saved) {
*data++ = saved_char;
mlen--;
saved = false;
continue;
}
{
cyg_uint8 tmp;
DP_IN_DATA(dp->data, tmp);
#if DEBUG & 4
printf(" %02x", tmp);
if (0 == (++dx % 16)) printf("\n ");
#endif
*data++ = tmp;;
mlen--;
}
}
#if DEBUG & 4
printf("\n");
#endif
}
}
}
/*
This routine is called to send data to the hardware. It is known a-priori
that there is free buffer space (dp->tx_next).
*/
static void
dp83902a_send(unsigned char *data, int total_len, unsigned long key)
{
struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
cyg_uint8 *base = dp->base;
int len, start_page, pkt_len, i, isr;
#if DEBUG & 4
int dx;
#endif
DEBUG_FUNCTION();
len = pkt_len = total_len;
if (pkt_len < IEEE_8023_MIN_FRAME) pkt_len = IEEE_8023_MIN_FRAME;
start_page = dp->tx_next;
if (dp->tx_next == dp->tx_buf1) {
dp->tx1 = start_page;
dp->tx1_len = pkt_len;
dp->tx1_key = key;
dp->tx_next = dp->tx_buf2;
} else {
dp->tx2 = start_page;
dp->tx2_len = pkt_len;
dp->tx2_key = key;
dp->tx_next = dp->tx_buf1;
}
#if DEBUG & 5
printf("TX prep page %d len %d\n", start_page, pkt_len);
#endif
DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
{
/* Dummy read. The manual sez something slightly different, */
/* but the code is extended a bit to do what Hitachi's monitor */
/* does (i.e., also read data). */
cyg_uint16 tmp;
int len = 1;
DP_OUT(base, DP_RSAL, 0x100-len);
DP_OUT(base, DP_RSAH, (start_page-1) & 0xff);
DP_OUT(base, DP_RBCL, len);
DP_OUT(base, DP_RBCH, 0);
DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_RDMA | DP_CR_START);
DP_IN_DATA(dp->data, tmp);
}
#ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA
/* Stall for a bit before continuing to work around random data */
/* corruption problems on some platforms. */
CYGACC_CALL_IF_DELAY_US(1);
#endif
/* Send data to device buffer(s) */
DP_OUT(base, DP_RSAL, 0);
DP_OUT(base, DP_RSAH, start_page);
DP_OUT(base, DP_RBCL, pkt_len & 0xFF);
DP_OUT(base, DP_RBCH, pkt_len >> 8);
DP_OUT(base, DP_CR, DP_CR_WDMA | DP_CR_START);
/* Put data into buffer */
#if DEBUG & 4
printf(" sg buf %08lx len %08x\n ", (unsigned long) data, len);
dx = 0;
#endif
while (len > 0) {
#if DEBUG & 4
printf(" %02x", *data);
if (0 == (++dx % 16)) printf("\n ");
#endif
DP_OUT_DATA(dp->data, *data++);
len--;
}
#if DEBUG & 4
printf("\n");
#endif
if (total_len < pkt_len) {
#if DEBUG & 4
printf(" + %d bytes of padding\n", pkt_len - total_len);
#endif
/* Padding to 802.3 length was required */
for (i = total_len; i < pkt_len;) {
i++;
DP_OUT_DATA(dp->data, 0);
}
}
#ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA
/* After last data write, delay for a bit before accessing the */
/* device again, or we may get random data corruption in the last */
/* datum (on some platforms). */
CYGACC_CALL_IF_DELAY_US(1);
#endif
/* Wait for DMA to complete */
do {
DP_IN(base, DP_ISR, isr);
} while ((isr & DP_ISR_RDC) == 0);
/* Then disable DMA */
DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
/* Start transmit if not already going */
if (!dp->tx_started) {
if (start_page == dp->tx1) {
dp->tx_int = 1; /* Expecting interrupt from BUF1 */
} else {
dp->tx_int = 2; /* Expecting interrupt from BUF2 */
}
dp83902a_start_xmit(start_page, pkt_len);
}
}
WaitNotifyThread::~WaitNotifyThread()
{
DEBUG_FUNCTION();
}
void SslServer::processCommandXML(QSslSocket *socket, const QByteArray &data)
{
qint32 argc;
QString cmd;
QByteArray arg1, arg2, arg3, arg4, arg5,
arg6, arg7, arg8, arg9, arg10;
if (!XMLReader(data, &argc, &cmd,
&arg1, &arg2, &arg3, &arg4, &arg5,
&arg6, &arg7, &arg8, &arg9, &arg10))
{
writeWarning(socket, "Invalid XML", true);
return;
}
if (cmd == "LOGIN")
{
if (arg1.isEmpty() || arg2.isEmpty()
|| arg3.isEmpty() || arg4.isEmpty()
|| arg5.isEmpty())
{
writeWarning(socket, "Invalid XML", true);
return;
}
QByteArray peer_negotiation_string = arg1;
QByteArray peer_id = arg2;
QByteArray password = arg3;
bool user_unavailable = getValue<bool>(arg4);
bool new_user = getValue<bool>(arg5);
QString code = QLatin1String(arg6);
if (peer_negotiation_string != NEGOTIATION_STRING)
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "Invalid NEGOTIATION STRING!");
writeWarning(socket, "Invalid NEGOTIATION STRING!", true);
return;
}
if (m_id_list.contains(peer_id))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "This user is already connected!");
writeWarning(socket, "This user is already connected!", true);
return;
}
if (new_user)
{
if (m_sql.userExists("root"))
{
if (!m_code_list.contains(code))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "Invalid code!");
writeWarning(socket, "Invalid code!", true);
return;
}
else
{
m_code_list.removeAll(code);
}
}
else if (cleanString(QLatin1String(peer_id)) != "root")
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "Need to create root account first!");
writeWarning(socket, "Need to create root account first!", true);
return;
}
if (m_sql.userExists(cleanString(QLatin1String(peer_id))))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "User already exists!");
writeWarning(socket, "User already exists!", true);
return;
}
else if (!m_sql.createUser(cleanString(QLatin1String(peer_id)), cleanString(QLatin1String(password))))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "Can't create new user!");
writeWarning(socket, "Can't create new user!", true);
return;
}
}
if (!m_sql.loginUser(cleanString(QLatin1String(peer_id)), cleanString(QLatin1String(password))))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "Can't login with this user and password!");
writeWarning(socket, "Can't login with this user and password!", true);
return;
}
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "User logged in!");
m_id_list.append(peer_id);
m_id_hash.insert(socket, peer_id);
if (user_unavailable)
m_unavailable_list.append(peer_id);
QByteArray data;
data.append(getBytes<quint8>(ServerCommand::LoggedIn));
socket->write(getBytes<qint32>(data.size()));
socket->write(data);
}
else if (cmd == "REQUEST_SETTINGS")
{
QString ui_path;
QString js_path;
QString id = QLatin1String(m_id_hash[socket]);
if (id != "root")
{
ui_path = "../data/settings.ui";
js_path = "../data/settings.js";
}
else
{
ui_path = "../data/settings_root.ui";
js_path = "../data/settings_root.js";
}
QFile ui_file(ui_path);
QFile js_file(js_path);
if (!ui_file.open(QFile::ReadOnly) || !js_file.open(QFile::ReadOnly))
{
DEBUG_FUNCTION("Can't send settings file");
writeWarning(socket, "Can't send settings file", true);
return;
}
QByteArray ui_data = ui_file.readAll();
QByteArray js_data = js_file.readAll();
QByteArray xml_data = XMLWriter("SETTINGS", ui_data, js_data);
writeCommandXML(socket, xml_data);
}
else if (cmd == "DELETE_ACCOUNT")
{
QString id = QLatin1String(m_id_hash[socket]);
if (id == "root")
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "Invalid operation!");
writeWarning(socket, "Invalid operation!", true);
return;
}
if (m_sql.deleteUser(id))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User deleted sucessfully!");
writeWarning(socket, "User deleted sucessfully!", true);
}
else
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "Error deleting user!");
writeWarning(socket, "Error deleting user!", true);
}
}
else if (cmd == "CHANGE_ACCOUNT_PASSWORD")
{
if (arg1.isEmpty())
{
writeWarning(socket, "Invalid XML", true);
return;
}
QByteArray password = arg1;
if (m_sql.changePassword(m_id_hash[socket], cleanString(QLatin1String(password))))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User password changed sucessfully!");
writeWarning(socket, "User password changed sucessfully!", true);
}
else
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "Error changing user password!");
writeWarning(socket, "Error changing user password!", true);
}
}
else if (cmd == "REQUEST_CODE")
{
QByteArray id = m_id_hash[socket];
if (QLatin1String(id) != "root")
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "Invalid operation!");
writeWarning(socket, "Invalid operation!", true);
return;
}
QString code;
do
{
code = QString(OpenSslLib::RANDbytes(4).toHex());
code.prepend("#");
}
while (m_code_list.contains(code));
m_code_list.append(code);
QTimer::singleShot(60 * 60 * 1000, [=]{
m_code_list.removeAll(code);
});
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "Sending code!");
QByteArray xml_data = XMLWriter("CODE", "edit_code", code.toLatin1());
writeCommandXML(socket, xml_data);
}
else
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "Invalid operation!");
writeWarning(socket, "Invalid operation!", true);
}
}
void WaitNotifyThread::SetUDPFd(LWPR::SOCKET_FD_T fd)
{
DEBUG_FUNCTION();
m_nUDPFd = fd;
}
};
struct dispatch_queue_attr_s _dispatch_queue_attr_concurrent = {
.do_vtable = DISPATCH_VTABLE(queue_attr),
.do_ref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
.do_xref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
.do_next = (dispatch_queue_attr_t)DISPATCH_OBJECT_LISTLESS,
};
#pragma mark -
#pragma mark dispatch_vtables
DISPATCH_VTABLE_INSTANCE(semaphore,
.do_type = DISPATCH_SEMAPHORE_TYPE,
.do_kind = "semaphore",
.do_debug = DEBUG_FUNCTION(semaphore, _dispatch_semaphore_debug),
.do_invoke = NULL,
.do_probe = NULL,
.do_dispose = DISPOSE_FUNCTION(semaphore, _dispatch_semaphore_dispose),
);
DISPATCH_VTABLE_INSTANCE(group,
.do_type = DISPATCH_GROUP_TYPE,
.do_kind = "group",
.do_debug = DEBUG_FUNCTION(group, _dispatch_semaphore_debug),
.do_invoke = NULL,
.do_probe = NULL,
.do_dispose = DISPOSE_FUNCTION(group, _dispatch_semaphore_dispose),
);
DISPATCH_VTABLE_INSTANCE(queue,
void SslServer::process(const PeerData &pd)
{
QByteArray data = pd.data;
if (data.isEmpty())
return;
quint8 command = getValue<quint8>(data.mid(0, 1));
data.remove(0, 1);
QSslSocket *socket = m_socket_hash[pd.descriptor];
if (!socket)
return;
switch (command)
{
case ServerCommand::PeerTryConnect:
{
if (data.size() != 20)
{
removeSocket(socket);
return;
}
QByteArray peer_id = data;
peer_id = cleanString(QLatin1String(peer_id)).toLatin1().leftJustified(peer_id.length(), char(0), true);
if (m_unavailable_list.contains(peer_id))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User target:" << qPrintable(peer_id) << "Attempt to connect to unavailable user!");
writeWarning(socket, "You're trying to connect to a unavailable user!");
return;
}
if (peer_id == m_id_hash[socket])
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User target:" << qPrintable(peer_id) << "Attempt to connect to itself!");
writeWarning(socket, "You're trying to connect to itself!");
return;
}
if (!m_id_list.contains(peer_id))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User target:" << qPrintable(peer_id) << "Attempt to connect to non connected user!");
writeWarning(socket, "You're trying to connect to a non connected user!");
return;
}
QSslSocket *target_socket = m_id_hash.key(peer_id);
if (m_connecting_connected_list.contains(target_socket))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User target:" << qPrintable(peer_id) << "Attempt to connect to already connected user!");
writeWarning(socket, "User already connected!");
return;
}
m_connecting_connected_list.append(socket);
m_connecting_connected_list.append(target_socket);
QByteArray data;
data.append(getBytes<quint8>(ServerCommand::ConnectionRequested));
data.append(getBytes<quint32>(socket->localAddress().toIPv4Address()));
data.append(m_id_hash[socket]);
m_accept_hash.insert(target_socket, socket);
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User target:" << qPrintable(peer_id) << "Trying to connect to peer!");
target_socket->write(getBytes<qint32>(data.size()));
target_socket->write(data);
break;
}
case ServerCommand::ConnectionAnswer:
{
if (data.size() != 1)
{
removeSocket(socket);
return;
}
QSslSocket *socket_starter = m_accept_hash[socket];
bool accepted = getValue<bool>(data.mid(0, 1));
if (!socket_starter)
{
m_connecting_connected_list.removeAll(socket_starter);
m_connecting_connected_list.removeAll(socket);
if (accepted)
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User disconnected or canceled operation!");
writeWarning(socket, "Can't connect to user because it's disconnected or canceled operation!");
}
return;
}
if (!accepted)
{
QSslSocket *socket1 = socket_starter;
QSslSocket *socket2 = socket;
m_accept_hash.remove(socket1);
m_accept_hash.remove(socket2);
m_connecting_connected_list.removeAll(socket1);
m_connecting_connected_list.removeAll(socket2);
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User target:" << qPrintable(m_id_hash.value(socket_starter)) << "User refused connection!");
writeWarning(socket_starter, "User refused connection!");
return;
}
QSslSocket *socket1 = socket;
QSslSocket *socket2 = socket_starter;
m_connected_1.insert(socket1, socket2);
m_connected_2.insert(socket2, socket1);
QByteArray data1;
QByteArray data2;
data1.append(getBytes<quint8>(ServerCommand::ConnectedToPeer));
data2.append(getBytes<quint8>(ServerCommand::ConnectedToPeer));
QByteArray password = OpenSslLib::RANDbytes(32);
data1.append(m_id_hash[socket1]);
data1.append(password);
data2.append(m_id_hash[socket2]);
data2.append(password);
socket1->write(getBytes<qint32>(data2.size()));
socket1->write(data2);
socket2->write(getBytes<qint32>(data1.size()));
socket2->write(data1);
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket_starter))
<< "User target:" << qPrintable(m_id_hash.value(socket)) << "Connected!");
break;
}
case ServerCommand::DisconnectedFromPeer:
{
QSslSocket *target_socket = m_connected_1.value(socket);
if (!target_socket)
target_socket = m_connected_2.value(socket);
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User target:" << qPrintable(m_id_hash.value(target_socket)) << "Disconnected from peer!");
disconnectedFromPeer(socket);
break;
}
case ServerCommand::P2PData:
{
QSslSocket *target_socket = m_connected_1.value(socket);
if (!target_socket)
target_socket = m_connected_2.value(socket);
if (!target_socket)
break;
data.prepend(getBytes<quint8>(ServerCommand::P2PData));
target_socket->write(getBytes<qint32>(data.size()));
target_socket->write(data);
m_alive_hash[socket].restart();
m_alive_hash[target_socket].restart();
break;
}
case ServerCommand::Alive:
{
m_alive_hash[socket].restart();
break;
}
case ServerCommand::XML:
{
processCommandXML(socket, data);
break;
}
default:
{
removeSocket(socket);
return;
}
}
}
WaitNotifyThread::WaitNotifyThread()
: m_nUDPFd(-1)
{
DEBUG_FUNCTION();
}
SslServer::SslServer(QObject *parent) : QObject(parent)
{
qRegisterMetaType<PeerData>("PeerData");
m_max_connections = 0;
m_server = nullptr;
QByteArray password;
if (!QFileInfo("../data/cert.pem").exists() || !QFileInfo("../data/key.pem").exists())
{
QByteArray confirm_password;
password = getPassword("Enter password to encrypt private key:");
confirm_password = getPassword("Repeat password to encrypt private key:");
printf("\n");
fflush(stdout);
if (password != confirm_password)
{
password.fill(char(0));
confirm_password.fill(char(0));
DEBUG_FUNCTION("Different passwords!");
return;
}
confirm_password.fill(char(0));
DEBUG_FUNCTION("Generating certificate...");
Certificate certificate_genarator;
bool success = certificate_genarator.generate("US", "Server", "127.0.0.1", password);
if (!success)
{
DEBUG_FUNCTION("Keys not generated!" << "Error(s):" << qPrintable(QString("\n%0").arg(certificate_genarator.errorString())));
return;
}
DEBUG_FUNCTION("Keys generated!");
}
QFile key_file("../data/key.pem");
if (!key_file.open(QFile::ReadOnly))
{
DEBUG_FUNCTION("Private key file could not be openned!");
return;
}
QFile cert_file("../data/cert.pem");
if (!cert_file.open(QFile::ReadOnly))
{
DEBUG_FUNCTION("Public key file could not be openned!");
return;
}
if (password.isNull())
password = getPassword("Enter password to decrypt private key:");
printf("\n");
fflush(stdout);
m_key = QSslKey(&key_file, QSsl::Rsa, QSsl::Pem, QSsl::PrivateKey, password);
password.fill(char(0));
if (m_key.isNull())
{
DEBUG_FUNCTION("Private key is null!");
return;
}
m_cert = QSslCertificate(&cert_file, QSsl::Pem);
if (m_cert.isNull())
{
DEBUG_FUNCTION("Public key is null!");
return;
}
QByteArray hash = m_cert.digest(QCryptographicHash::Sha256).toHex().toUpper();
QByteArray formatted_hash;
for (int i = hash.size() - 2; i >= 0; i -= 2)
{
formatted_hash.prepend(hash.mid(i, 2));
formatted_hash.prepend(":");
}
formatted_hash.remove(0, 1);
DEBUG_FUNCTION("Certificate fingerprint:" << qPrintable(formatted_hash));
key_file.close();
cert_file.close();
DEBUG_FUNCTION("Openning database...");
if (!m_sql.open())
{
DEBUG_FUNCTION("Could not open database!");
return;
}
DEBUG_FUNCTION("Database openned!");
listen();
}
/**
* @force_hide: This option is used by the auto hide feature, so we can ignore the checks to focus tilda instead
* of pulling up.
*/
void pull (struct tilda_window_ *tw, enum pull_state state, gboolean force_hide)
{
DEBUG_FUNCTION ("pull");
DEBUG_ASSERT (tw != NULL);
DEBUG_ASSERT (state == PULL_UP || state == PULL_DOWN || state == PULL_TOGGLE);
gint i;
gboolean needsFocus = !tw->focus_loss_on_keypress
&& !gtk_window_is_active(GTK_WINDOW(tw->window))
&& !force_hide
&& !tw->hide_non_focused;
if (tw->current_state == DOWN && needsFocus) {
/**
* See tilda_window.c in focus_out_event_cb for an explanation about focus_loss_on_keypress
* This conditional branch will only focus tilda but it does not actually pull the window up.
*/
TRACE (g_print("Tilda window not focused but visible\n"));
gdk_x11_window_set_user_time(gtk_widget_get_window(tw->window),
tomboy_keybinder_get_current_event_time());
tilda_window_set_active(tw);
} else
if (tw->current_state == UP && state != PULL_UP) {
/* Keep things here just like they are. If you use gtk_window_present() here, you
* will introduce some weird graphical glitches. Also, calling gtk_window_move()
* before showing the window avoids yet more glitches. You should probably not use
* gtk_window_show_all() here, as it takes a long time to execute.
*
* Overriding the user time here seems to work a lot better than calling
* gtk_window_present_with_time() here, or at the end of the function. I have
* no idea why, they should do the same thing. */
gdk_x11_window_set_user_time (gtk_widget_get_window (tw->window),
tomboy_keybinder_get_current_event_time());
gtk_window_move (GTK_WINDOW(tw->window), config_getint ("x_pos"), config_getint ("y_pos"));
gtk_widget_show (GTK_WIDGET(tw->window));
/* Nasty code to make metacity behave. Starting at metacity-2.22 they "fixed" the
* focus stealing prevention to make the old _NET_WM_USER_TIME hack
* not work anymore. This is working for now... */
tilda_window_set_active (tw);
/* The window should maintain its properties when it is merely hidden, but it does
* not. If you delete the following call, the window will not remain visible
* on all workspaces after pull()ing it up and down a number of times.
*
* Note that the "Always on top" property doesn't seem to go away, only this
* property (Show on all desktops) does... */
if (config_getbool ("pinned"))
gtk_window_stick (GTK_WINDOW (tw->window));
if (config_getbool ("animation"))
{
for (i=0; i<16; i++)
{
gtk_window_move (GTK_WINDOW(tw->window), posIV[2][i], posIV[0][i]);
gtk_window_resize (GTK_WINDOW(tw->window), posIV[3][i], posIV[1][i]);
process_all_pending_gtk_events ();
g_usleep (config_getint ("slide_sleep_usec"));
}
}
debug_printf ("pull(): MOVED DOWN\n");
tw->current_state = DOWN;
}
else if (state != PULL_DOWN)
{
if (config_getbool ("animation"))
{
for (i=15; i>=0; i--)
{
gtk_window_move (GTK_WINDOW(tw->window), posIV[2][i], posIV[0][i]);
gtk_window_resize (GTK_WINDOW(tw->window), posIV[3][i], posIV[1][i]);
process_all_pending_gtk_events ();
g_usleep (config_getint ("slide_sleep_usec"));
}
}
/* All we have to do at this point is hide the window.
* Case 1 - Animation on: The window has shrunk, just hide it
* Case 2 - Animation off: Just hide the window */
gtk_widget_hide (GTK_WIDGET(tw->window));
debug_printf ("pull(): MOVED UP\n");
tw->current_state = UP;
}
}
static int send_data_net(struct NET_TASK *ev_task ,struct NET_DATA_NODE_T *data_nod)
{
int ret;
ISIL_AV_PACKET *av_pck;
struct sockaddr_in *sa = NULL;
if( !ev_task || !data_nod ) {
return -1;
}
if( !data_nod->arg ) {
return -1;
}
av_pck = (ISIL_AV_PACKET *)(data_nod->arg);
if( !av_pck->buff ) {
return -1;
}
//isil_av_packet_debug(av_pck);
#if 1
if(ev_task->trans_type == NET_TCP_E) {
sa = NULL;
}
else{
sa = &ev_task->sa;
}
#endif
switch (av_pck->frm_type) {
case ISIL_H264_DATA:{
H264_INF_T *h264_inf_ptr = (H264_INF_T *)( &(av_pck->data_type_u.h264_inf));
if(h264_inf_ptr->nalu_type == H264_NALU_SPS) {
update_h264_sps_buff(ev_task,av_pck);
}
else if(h264_inf_ptr->nalu_type == H264_NALU_PPS) {
update_h264_pps_buff(ev_task ,av_pck);
}
else if(h264_inf_ptr->nalu_type == H264_NALU_IDRSLICE) {
if( !ev_task->enc_param ) {
return -1;
}
struct h264_param_t *h264_param_ptr = (struct h264_param_t *)ev_task->enc_param;
ret = net_handle_5864_IDR_frame(ev_task->fd,
(void*)sa,
av_pck,
REALSTREAM,
0,
(void *)h264_param_ptr->sps_buff,
h264_param_ptr->sps_len,
(void *)h264_param_ptr->pps_buff,
h264_param_ptr->pps_len);
if( ret < 0 ) {
return -1;
}
}
else if( h264_inf_ptr->nalu_type == H264_NALU_PSLICE ){
if( ev_task->frame_type == NET_ONLY_NEED_I_FRAME_E ){
DEBUG_FUNCTION();
return 0;
}
ret = net_handle_5864_I_P_frame(ev_task->fd,
(void *)sa,
av_pck,
REALSTREAM,
0);
if( ret < 0 ) {
return -1;
}
}
else if( h264_inf_ptr->nalu_type == H264_NALU_ISLICE ) {
ret = net_handle_5864_I_P_frame(ev_task->fd,
(void *)sa,
av_pck,
REALSTREAM,
0);
if( ret < 0 ) {
return -1;
}
}
else{
fprintf(stderr,"h264_inf nal type[%d] unkown .\n",h264_inf_ptr->nalu_type);
return 0;
}
}
break;
case ISIL_AUDIO_DATA:{
ret = net_handle_5864_audio_frame(ev_task->fd , (void *)sa,av_pck ,REALSTREAM,0);
if( ret < 0 ) {
return -1;
}
}
break;
case ISIL_MJPEG_DATA:{
ret = net_handle_5864_MJPEG_frame(ev_task->fd , (void *)sa, av_pck );
if( ret < 0 ) {
return -1;
}
}
break;
default:
return -1;
}
return 0;
}
/*
* This function is called when a packet has been received. It's job is
* to prepare to unload the packet from the hardware. Once the length of
* the packet is known, the upper layer of the driver can be told. When
* the upper layer is ready to unload the packet, the internal function
* 'dp83902a_recv' will be called to actually fetch it from the hardware.
*/
static void
dp83902a_RxEvent(void)
{
struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
u8 *base = dp->base;
__maybe_unused u8 rsr;
u8 rcv_hdr[4];
int i, len, pkt, cur;
DEBUG_FUNCTION();
DP_IN(base, DP_RSR, rsr);
while (true) {
/* Read incoming packet header */
DP_OUT(base, DP_CR, DP_CR_PAGE1 | DP_CR_NODMA | DP_CR_START);
DP_IN(base, DP_P1_CURP, cur);
DP_OUT(base, DP_P1_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
DP_IN(base, DP_BNDRY, pkt);
pkt += 1;
if (pkt == dp->rx_buf_end)
pkt = dp->rx_buf_start;
if (pkt == cur) {
break;
}
DP_OUT(base, DP_RBCL, sizeof(rcv_hdr));
DP_OUT(base, DP_RBCH, 0);
DP_OUT(base, DP_RSAL, 0);
DP_OUT(base, DP_RSAH, pkt);
if (dp->rx_next == pkt) {
if (cur == dp->rx_buf_start)
DP_OUT(base, DP_BNDRY, dp->rx_buf_end - 1);
else
DP_OUT(base, DP_BNDRY, cur - 1); /* Update pointer */
return;
}
dp->rx_next = pkt;
DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
DP_OUT(base, DP_CR, DP_CR_RDMA | DP_CR_START);
#ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_RX_DMA
CYGACC_CALL_IF_DELAY_US(10);
#endif
/* read header (get data size)*/
for (i = 0; i < sizeof(rcv_hdr);) {
DP_IN_DATA(dp->data, rcv_hdr[i++]);
}
#if DEBUG & 5
printf("rx hdr %02x %02x %02x %02x\n",
rcv_hdr[0], rcv_hdr[1], rcv_hdr[2], rcv_hdr[3]);
#endif
len = ((rcv_hdr[3] << 8) | rcv_hdr[2]) - sizeof(rcv_hdr);
/* data read */
uboot_push_packet_len(len);
if (rcv_hdr[1] == dp->rx_buf_start)
DP_OUT(base, DP_BNDRY, dp->rx_buf_end - 1);
else
DP_OUT(base, DP_BNDRY, rcv_hdr[1] - 1); /* Update pointer */
}
}
