/*
 * Developed by Hillstone Software. http://www.hillstone-software.com
 * HS X25 with RFC1613 XOT - Demo / Test Application
 */
#include "HsX25_Demo.h"
#include "Bl_win.h"
#include <commctrl.h>
#include <stdio.h>
#include <stdlib.h>
#include "resource.h"

TCHAR			szWindowClass[]		= " ";
HINSTANCE		hInst;
TCHAR			szTitle[] = "HsX.25 1.2 (With RFC1613 XOT) C Source Library Demo (www.hillstone-software.com)";

HWND			hwnd_main;
HWND			dlg_main;
HBRUSH			hbrush1				= NULL;

unsigned char *pktsz[] =
{
	{"128"},
	{"256"},
	{"512"},
	{"1024"},
	0,
};

unsigned char *wszs[] =
{
	{"1"},
	{"2"},
	{"3"},
	{"4"},
	{"5"},
	{"6"},
	{"7"},
	0,
};

static int		num_vcs_up			= 0;
static int		num_events			= 0;
static int 		pkttrace_len 		= 0;
static int		low_lcn				= 2048;
static int		high_lcn			= 4095;
static long		app_timer			= 0;
static long		stats_k				= 0;
static long		rq_k				= 0;
static unsigned char static_str_buf[200] = {0};

static timer_cell_t timers[APP_MAX_TIMERS] = {0};

x25app_vc_t	vclist[4096] = {0};

/* request queue */
request_q_t	rq = {0};

hs_x25_conn_t conn = {0};

int	rq_put(int type, void *pData, int data_size)
{
	void *p;

	if (rq.size >= MAX_REQS)
		return FALSE;

	p = malloc(data_size);
	if (!p) return FALSE;

	memcpy(p, pData, data_size);

	rq.cells[rq.in].req_type = type;
	rq.cells[rq.in++].req_data = (long)p;

	if (rq.in == MAX_REQS)
		rq.in = 0;

	rq.size++;

	return TRUE;
}

void service_rq(void)
{
	void *p;
	int type;
	hs_x25_conn_t *pConn;
	data_cell_t	*dc;
	int rc;

	if (rq.size == 0)
		return;

	type = rq.cells[rq.out].req_type;
	p = (void *)rq.cells[rq.out].req_data;

	switch (type)
	{
	case REQ_CALL:
		pConn = (hs_x25_conn_t *)p;
		rc = submit_call(pConn);
		break;

	case REQ_DATA:
		dc = (data_cell_t *)p;
		rc = submit_data(dc->lci, dc->bufp, dc->len, dc->qbit);
		break;
	}

	if ((type == REQ_DATA) && (rc == HS_X25_RC_TXQ_FULL))
		return;

	rq.out++;
	if (rq.out == MAX_REQS)
		rq.out = 0;

	rq.size--;

	if (dc->release_buf)
		free(dc->bufp);
		
	free(p);
}

/* allocate new timer call */
static timer_cell_t *timer_alloc(void)
{
	timer_cell_t 	*t;
	long			i;

	for (i=0; i<APP_MAX_TIMERS; i++)
	{
		t = &timers[i];
		if (!t->allocated)
		{
			memset(t, 0, sizeof (timer_cell_t));
			t->allocated = TRUE;
			return t;
		}
	}

	return NULL;
}

/* release timer cell */
static void timer_free(timer_cell_t *t)
{
	t->allocated = FALSE;
}

/* find timer cell by timer handle */
static timer_cell_t *timer_find(long timer_handle)
{
	timer_cell_t 	*t;
	long			i;

	for (i=0; i<APP_MAX_TIMERS; i++)
	{
		t = &timers[i];
		if ((t->allocated) && (t->timer_handle == timer_handle))
			return t;
	}

	return NULL;	
}

/* windows timer callback */
TIMERPROC TimerProc(HWND hwnd,  UINT uMsg, UINT_PTR idEvent,  DWORD dwTime)
{
	timer_cell_t *t;

	KillTimer(hwnd, idEvent);

	t = timer_find(idEvent);
	if (!t) return 0;

	t->callback(t->user_handle);
	timer_free(t);
	return 0;
}

static void clear_stats(void)
{
	SetDlgItemText(dlg_main, IDC_STATIC_SLCI, ""); 
	SetDlgItemText(dlg_main, IDC_STATIC_SRES_TX, "");
	SetDlgItemText(dlg_main, IDC_STATIC_SRES_RX, "");
	SetDlgItemText(dlg_main, IDC_STATIC_SDTX, "");
	SetDlgItemText(dlg_main, IDC_STATIC_SDRX, "");
	SetDlgItemText(dlg_main, IDC_STATIC_SWIN, ""); 
}

/* windows timer callback */
TIMERPROC AppTimerProc(HWND hwnd,  UINT uMsg, UINT_PTR idEvent,  DWORD dwTime)
{
	int lci;
	hs_x25_stats_t stat;
	x25app_vc_t *vc;
	unsigned char s[80];

	rq_k++;
	if (rq_k == APP_TMR_RQ_K)
	{
		rq_k = 0;
		service_rq();		
	}

	HsX25Tick();

	stats_k++;
	// time to pull stats for a selected call if any
	if (stats_k == APP_TMR_STATS_K)
	{
		stats_k = 0;
		if (ListViewVCGetSelectedLCI(&lci))
		{
			vc = &vclist[lci];
			HsX25GetStats(vc->vchan, &stat);
			SetDlgItemInt(dlg_main, IDC_STATIC_SLCI, lci, FALSE); 

			memset(s, 0, sizeof s);
			sprintf(s, "%u", stat.tx.reset);
			SetDlgItemText(dlg_main, IDC_STATIC_SRES_TX, s);

			memset(s, 0, sizeof s);
			sprintf(s, "%u", stat.rx.reset);
			SetDlgItemText(dlg_main, IDC_STATIC_SRES_RX, s);

			memset(s, 0, sizeof s);
			sprintf(s, "%u", stat.tx.data);
			SetDlgItemText(dlg_main, IDC_STATIC_SDTX, s);

			memset(s, 0, sizeof s);
			sprintf(s, "%u", stat.rx.data);
			SetDlgItemText(dlg_main, IDC_STATIC_SDRX, s);

			SetDlgItemInt(dlg_main, IDC_STATIC_SWIN, stat.w, FALSE); 
		}
		else
		{
			clear_stats();
		}
	}
	
	return 0;
}

/*
 * called from X25 to start a timer
 * handle - HsX25 handle
 * secs - timeout in seconds
 * callback - timer expired callback address (function in HsX25 code)
 * tid - timer id
 * return - timer handle
 */
long hs_x25_start_timer(long handle, unsigned long secs, hs_x25_timer_callback_t *callback, int tid)
{
	timer_cell_t	*t;

	if (!callback) 
	{
		write_event("hs_x25_start_timer: cannot start timer: NULL callback");
		return 0;
	}

	t = timer_alloc();
	if (!t) 
	{
		write_event("hs_x25_start_timer: cannot start timer: no free timer cells");	
		return 0;
	}

	t->timer_handle = (long)SetTimer(NULL, 0, (UINT)(secs * 1000), (TIMERPROC)TimerProc);
	if (t->timer_handle == 0)
	{
		write_event("hs_x25_start_timer: cannot start windows timer");
		timer_free(t);
		return 0;
	}

	t->user_handle = handle;
	t->callback = callback;
	 
	return t->timer_handle;
}

/* called from X25 to stop a timer */
void hs_x25_stop_timer(long timer_handle, int tid)
{
	timer_cell_t *t = timer_find(timer_handle);

	if (!t) return;

	KillTimer(0, (UINT_PTR )timer_handle);
	timer_free(t);	
}

BOOL InitListView (HWND hwndListView)
{
	int index;                      
	LV_COLUMN lvColumn;    
	
	TCHAR szString[4][20] = {TEXT("LCI"),
                           TEXT("In/Out"), 
                           TEXT("Called NUA"), 
                           TEXT("Calling NUA"), 
	};
	
	int	clen[4] = {40,45, 100,100};

	int i = 0;

  	// Initialize the columns in the list view.
  	lvColumn.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
  	lvColumn.fmt = LVCFMT_LEFT;

  	// Insert the five columns in the list view.
  	for (index = 0; index < 4; index++)
  	{
    	lvColumn.pszText = szString[index];
		lvColumn.cx = clen[index];
    	ListView_InsertColumn (hwndListView, index, &lvColumn);
  	}

	ListView_SetExtendedListViewStyle(hwndListView, LVS_EX_GRIDLINES | 
		                             LVS_EX_FULLROWSELECT);

  	return TRUE;
}

void ListViewVCAddCall(int lci, int is_out)
{
	LVITEM 		item = {0};
  	unsigned char s[60];
  	int 		index;

  	x25app_vc_t	*vc = &vclist[lci];

	HWND lvhan = GetDlgItem(dlg_main, IDC_LIST_VC);

	memset(&item, 0, sizeof (LVITEM));

	item.mask = LVIF_TEXT | LVIF_PARAM;

	memset(s, 0, sizeof s);
	sprintf(s, "%d",lci);
	item.pszText = s;

	item.lParam = (LPARAM)lci;
	item.iItem = 0xffff;
	index = ListView_InsertItem(lvhan, (LPLVITEM)&item);

	memset(s, 0, sizeof s);
	sprintf(s, "%s", is_out ? "Out" : "In");
	ListView_SetItemText(lvhan, index, 1, s);

	ListView_SetItemText(lvhan, index, 2, vc->conn.called);
	ListView_SetItemText(lvhan, index, 3, vc->conn.calling);

	ListView_EnsureVisible(lvhan, index, 0);

	num_vcs_up++;
	SetDlgItemInt(dlg_main, IDC_STATIC_NVC, num_vcs_up, FALSE);
}

void ListViewVCDeleteCall(int lci)
{
    LVFINDINFO findinfo = {0};
	int i;

    findinfo.flags = LVFI_PARAM;
    findinfo.lParam = (LPARAM)lci;
    i = ListView_FindItem(GetDlgItem(dlg_main, IDC_LIST_VC), -1, &findinfo);

	if (i == -1) return;
    
	ListView_DeleteItem(GetDlgItem(dlg_main, IDC_LIST_VC), i);
	
	num_vcs_up--;
	SetDlgItemInt(dlg_main, IDC_STATIC_NVC, num_vcs_up, FALSE);
}

int ListViewVCGetSelectedLCI(int *lci)
{
	LRESULT iSelect;
	LVITEM	item = {0};

	iSelect=SendMessage(GetDlgItem(dlg_main, IDC_LIST_VC), LVM_GETNEXTITEM, -1, LVNI_FOCUSED);
	if (iSelect == -1)
	{
		return FALSE;
	}
			
	item.mask = LVIF_PARAM;
	item.iItem = (int)iSelect;
	ListView_GetItem(GetDlgItem(dlg_main, IDC_LIST_VC), &item);
	*lci = (int)item.lParam;

	return TRUE;
}

static void write_event(unsigned char *str)
{
	LVITEM 		item = {0};
  	unsigned char s[80];
  	int 		index;
  	int			*p;

	HWND lvhan = GetDlgItem(dlg_main, IDC_LIST_EV);

	memset(&item, 0, sizeof (LVITEM));

	item.mask = LVIF_TEXT | LVIF_PARAM;

	memset(s, 0, sizeof s);
	sprintf(s, "%s",str);
	item.pszText = s;

	item.lParam = (LPARAM)1;
	item.iItem = 0xffff;
	index = ListView_InsertItem(lvhan, (LPLVITEM)&item);

	ListView_EnsureVisible(lvhan, index, 0);

	p = &num_events;

	if (*p < MAX_EVENTS)
	{
		(*p)++;
	}
	else
	{
		ListView_DeleteItem(lvhan, 0);
	}
	
}

BOOL InitListViewTrace (HWND hwndListView)
{
	int index;                      
	LV_COLUMN lvColumn;    
	
	TCHAR szString[7][20] = {TEXT("LCI"),
                           TEXT("In/Out"), 
                           TEXT("Q"), 
                           TEXT("D"), 
                           TEXT("M"), 
                           TEXT("Decode"), 
                           TEXT("Raw Data"), 
	};
	
	int	clen[7] = {30,45, 20, 20,25,200,300};

	int i = 0;

  	// Initialize the columns in the list view.
  	lvColumn.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
  	lvColumn.fmt = LVCFMT_LEFT;

  	// Insert the five columns in the list view.
  	for (index = 0; index < 7; index++)
  	{
    	lvColumn.pszText = szString[index];
		lvColumn.cx = clen[index];
    	ListView_InsertColumn (hwndListView, index, &lvColumn);
  	}

	ListView_SetExtendedListViewStyle(hwndListView, LVS_EX_GRIDLINES | 
		                             LVS_EX_FULLROWSELECT);

  	return TRUE;
}

BOOL InitListAppView (HWND hwndListView)
{
	int index;                      
	LV_COLUMN lvColumn;    
	
	TCHAR szString[1][20] = {TEXT(" "),};
	
	int	clen[1] = {360};

	int i = 0;

  	// Initialize the columns in the list view.
  	lvColumn.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
  	lvColumn.fmt = LVCFMT_LEFT;
  	lvColumn.cx = 120;

  	// Insert the five columns in the list view.
  	for (index = 0; index < 1; index++)
  	{
    	lvColumn.pszText = szString[index];
		lvColumn.cx = clen[index];
    	ListView_InsertColumn (hwndListView, index, &lvColumn);
  	}

	ListView_SetExtendedListViewStyle(hwndListView, /*LVS_EX_GRIDLINES |*/ 
		                             LVS_EX_FULLROWSELECT);

  	return TRUE;
}

void WritePktTrace(int is_rx, unsigned char *buf, int len, long arg)
{
	LVITEM 		item = {0};
  	unsigned char s[MAX_TRC_ENTRY_LEN];
  	int 		index;
  	int i, n;
  	int rlen;
  	int rc;
  	int ev;
	hs_x25_pkt_info_t info = {0};
	int lci;

  	HWND lvhan = GetDlgItem(dlg_main, IDC_LIST_TRACE);

	rc = HsX25DecodePkt(buf, len, &ev, &info, 1);
	if (rc != HS_X25_RC_DECODE_OK)
	{
		lci = 0;
	}
	else
	{
		lci = (int)info.lci;
	}
	
	memset(&item, 0, sizeof (LVITEM));
	item.mask = LVIF_TEXT | LVIF_PARAM;

	memset(s, 0, sizeof s);
	sprintf(s, "%d", lci);
	item.pszText = s;

	item.lParam = (LPARAM)1;
	item.iItem = 0xffff;
	index = ListView_InsertItem(lvhan, (LPLVITEM)&item);

	ListView_SetItemText(lvhan, index, 1, is_rx ? "In":"Out");
	
	memset(s, 0, sizeof s);

	rlen = (len > 20) ? 20 : len;
	n = 0;
	for (i=0; i<rlen; i++) 
	{
		n += sprintf(&s[n], "%02x ", buf[i]);
	}
	ListView_SetItemText(lvhan, index, 6, s);

	memset(s, 0, sizeof s);

	if (rc == HS_X25_RC_DECODE_OK)
	{
		switch (ev)
		{
		case HS_X25_DAT:
			// M bit
			ListView_SetItemText(lvhan, index, 4, (info.pkt[2] & 0x10) ? "M":"");
			
			sprintf(s, "%s Pr %d Ps %d", info.pktname, info.Pr, info.Ps);
			break;

		case HS_X25_RR:
		case HS_X25_RNR:
			sprintf(s, "%s Pr %d", info.pktname, info.Pr);
			break;	

		default:
			sprintf(s, "%s", info.pktname);
			break;
		}

		ListView_SetItemText(lvhan, index, 5, s);

		// D bit
		ListView_SetItemText(lvhan, index, 3, (info.pkt[0] & 0x40) ? "D":"");

		// Q bit
		ListView_SetItemText(lvhan, index, 2, (info.pkt[0] & 0x80) ? "Q":"");		

	}
	else
	{
		ListView_SetItemText(lvhan, index, 5, "Decode Error (invalid packet)");	
	}

	ListView_EnsureVisible(lvhan, index, 0);

	if (pkttrace_len < MAX_PKT_TRACE_LEN)
	{
		pkttrace_len++;
	}
	else
	{
		ListView_DeleteItem(lvhan, 0);
	}
}

/* submit new listen */
int submit_new_listen(void)
{
	int rc;
	hs_x25_listen_t alisten = {0};
	unsigned char s[80] = {0};

	memset(&alisten, 0, sizeof (hs_x25_listen_t));

	alisten.l2_addr			= 0xffff;	// any unique link indentifier
	alisten.arg				= 1261;		// Listening TCP port
	alisten.take_any_call 	= (IsDlgButtonChecked(dlg_main, IDC_CHECK_ACC_ALL) == BST_CHECKED) ? 1 : 0;

	if (!alisten.take_any_call)
	{
		GetDlgItemText(dlg_main, IDC_EDIT_LOCAL_ADDR, alisten.called, sizeof alisten.called);
		alisten.called_len = strlen(alisten.called);
	}
	
	rc = HsX25Listen(&alisten);
	if (rc != HS_X25_RC_OK)
	{
		sprintf(s, "Submit X25 listen - already listening");
		write_event(s);
		return FALSE;
	}

	write_event("Submitted new listen OK");
	return TRUE;
}

/* event handler of X25 events */
void hs_x25_event_callback(long handle, int ev, long arg1, long arg2)
{
	unsigned char *buf;
	unsigned char s[100] = {0};
	int len;
	int i, lci, n;

	hs_x25_conn_t *pConn;
	hs_x25data_t *pDat;

	switch (ev)
	{
	case HS_X25_EV_CONN_FAIL_PKTLR:
		sprintf(s, "X.25 Connect failed: packet layer not ready LCI (%d)", (int)arg1);
		write_event(s);

		submit_new_listen();
		break;

	case HS_X25_EV_INCOMING_CALL_CONNECTED:
		pConn = (hs_x25_conn_t *)arg2;

		memcpy(&vclist[arg1].conn, pConn, sizeof(hs_x25_conn_t));
		vclist[arg1].vchan = handle;
		
		sprintf(s, "incoming call connected LCI (%d)", (int)arg1);
		write_event(s);

		vclist[arg1].is_out = FALSE;
		ListViewVCAddCall((int)arg1, FALSE);

		submit_new_listen();
		break;

	case HS_X25_EV_CALL_CONNECTED:
		sprintf(s, "X.25 Outgoing Call Connected LCI (%d)", (int)arg1);
		write_event(s);

		vclist[arg1].is_out = TRUE;
		ListViewVCAddCall((int)arg1, TRUE);
		
		break;

	case HS_X25_EV_DATA:
		lci = (int)arg2;

		pDat = (hs_x25data_t *)arg1;
		
		buf = pDat->bufp;
		len = pDat->len;
		
		// only display max 10 bytes
		sprintf(s, "DATA RX (LCI %d) (len %d) ", lci, len);
		write_event(s);		
		break;

	case HS_X25_EV_CALL_CLEAR_COMPLETE:
		ListViewVCDeleteCall((int)arg1);
		
		sprintf(s, "X.25 VC disconnect complete (%d)", (int)arg1);
		write_event(s);

		vclist[arg1].vchan = 0;

		if (!vclist[arg1].is_out)
			submit_new_listen();
		break;

	case HS_X25_EV_CALL_CLEARED:
		ListViewVCDeleteCall((int)arg1);
		
		sprintf(s, "X.25 VC disconnected by network (%d)", (int)arg1);
		write_event(s);

		vclist[arg1].vchan = 0;

		if (!vclist[arg1].is_out)
			submit_new_listen();
		break;		

	case HS_X25_EV_PKTLR_RESTARTED:
		ListViewVCDeleteCall((int)arg1);

		sprintf(s, "X.25 VC cleared (%d) packet layer restart", (int)arg1);
		write_event(s);
		break;

	case HS_X25_EV_EXP_DATA_TX_FAIL:
		sprintf(s, "X.25 failed to send exp. data. Previous exp data not confirmed");
		write_event(s);
		break;

	case HS_X25_EV_EXP_DATA_DELIVERED:
		sprintf(s, "X.25 expedited data delivered to remote");
		write_event(s);
		break;

	case HS_X25_EV_DATA_EXP:
		buf = (unsigned char *)arg1;
		len = (int)arg2;
		
		n = sprintf(s, "X.25 RX EXP DATA: ");
		for (i=0 ; i<len; i++)
			n += sprintf(&s[n], "%02x ", buf[i]);

		write_event(s);
		break;
	}
}

void hs_trace_cb(int is_rx, unsigned char *buf, int len, long arg)
{
	WritePktTrace(is_rx, buf, len, arg);
}

static void initialise_x25(HWND hDlg)
{
	unsigned char s[100] = {0};
	hs_x25_init_t init = {0};
	unsigned char ipaddr[16] = {0};
	BOOL translated;
	int rc;	

	init.api.event_cb = hs_x25_event_callback;
	init.api.start_timer = hs_x25_start_timer;
	init.api.stop_timer = hs_x25_stop_timer;

	init.is_dce = (int)(IsDlgButtonChecked(hDlg, IDC_RADIO_DCE) == BST_CHECKED) ? 1 : 0;

	memset(s, 0, sizeof(s));
	GetDlgItemText(hDlg, IDC_COMBO_PKTSZ, s, sizeof (s));
	init.pktsize = (int)atoi(s);

	memset(s, 0, sizeof(s));
	GetDlgItemText(hDlg, IDC_COMBO_WSIZE, s, sizeof (s));
	init.wsize = (int)atoi(s);
	
	init.is_rfc1613 = TRUE;
	GetDlgItemText(hDlg, IDC_IPADDRESS1, ipaddr, sizeof (ipaddr));
	init.rfc1613_peer_ip = ipaddr;

	init.hi_incoming_lcn = (int)GetDlgItemInt(hDlg, IDC_EDIT_HI_LCN, &translated, FALSE);
	init.lo_incoming_lcn = (int)GetDlgItemInt(hDlg, IDC_EDIT_LO_LCN, &translated, FALSE);

	init.support_dbit = (int)(IsDlgButtonChecked(hDlg, IDC_CHECK_ACC_DBIT) == BST_CHECKED) ? 1 : 0;
	
	init.trc_fn = hs_trace_cb;

	rc = HsX25Init(&init);
	if (rc != HS_X25_RC_OK)
	{
		memset(s, 0, sizeof(s));
		sprintf(s, "HS X25 init failed rc [%d]", rc);
		write_event(s);
		return;
	}

	if (!app_timer)
		app_timer = (long)SetTimer(NULL, 0, APP_TMR_MILLISEC, (TIMERPROC)AppTimerProc);

	write_event("Initialised HS X.25 Ok");

	submit_new_listen();
}

int submit_call(hs_x25_conn_t *conn)
{
	int rc;
	int lci;
	long vchan;
	unsigned char s[80] = {0};
	
	conn->l2_addr = 0xffff;
	conn->arg = 1261;
	
	rc = HsX25Connect(conn, &vchan, &lci);
	if (rc != HS_X25_RC_OK)
	{
		sprintf(s, "X25 connect failed rc [%d]", rc);
		write_event(s);
		return FALSE;
	}

	memcpy(&vclist[lci].conn, conn, sizeof (hs_x25_conn_t));
	vclist[lci].vchan = vchan;
	vclist[lci].is_out = FALSE;

	sprintf(s, "Making outgoing call (lci %d)", lci);
	write_event(s);
	
	return TRUE;	
}

int submit_data(int lci, unsigned char *p, int len, int qbit)
{
	int rc;
	long han; 
	unsigned char s[80] = {0};

	han = vclist[lci].vchan;

	rc = HsX25Data(han, p, len, qbit);
	if (rc != HS_X25_RC_OK)
	{
		if (rc == HS_X25_RC_BUF_TOO_BIG)
			sprintf(s, "X25 send data failed (Buffer Too Big)");
		else if (rc == HS_X25_RC_TXQ_FULL)
			sprintf(s, "X25 send data (TXQ Full, Will Try Later)");
		else
			sprintf(s, "X25 send data failed (rc %d)", rc);
		write_event(s);
		return rc;
	}

	sprintf(s, "Sending data (lci %d)", lci);
	write_event(s);

	return rc;
}

void submit_data_req(int lci, unsigned char *p, int len, int qbit, int release_buf)
{
	data_cell_t dc;

	memset(&dc, 0, sizeof (data_cell_t));

	dc.bufp = p;
	dc.lci = lci;
	dc.len = len;
	dc.qbit = qbit;
	dc.release_buf = release_buf;

	if (!rq_put(REQ_DATA, &dc, sizeof (data_cell_t)))
		write_event("Failed to submit data request");
}

static unsigned char hex2byte(unsigned char *buf)
{
	unsigned char hex[] = "0123456789ABCDEF";
	unsigned char b = 0;
    unsigned char b1, b2;
	int i;

    b1 = toupper(buf[0]);
    b2 = toupper(buf[1]);

	for (i = 0; i<16; i++)
	{
		if (b1 == hex[i])
		{
			b = (unsigned char)((i << 4) & 0xf0);
			break;
		}
	}

	for (i = 0; i<16; i++)
	{
		if (b2 == hex[i])
		{
			b |= (unsigned char)(i & 0x0f);
			break;
		}
	}
	
	return b;
}

/*
 * Convert source buffer from ASCII hex format to byte buffer. 
 * Source buffer length must be exactly twice as large as destination buffer length
 */
static void hexbuf2Bin(unsigned char *src, unsigned char *dst, int len)
{
	int i, n, ln;

    if ((len % 2) != 0)
        return;

    ln = (len / 2);

	n = 0;
	for (i=0; i<ln; i++)
	{
		dst[i] = hex2byte(&src[n]);
		n+=2;
	}

	return;
}

static LRESULT CALLBACK DlgWinCall(HWND hDlg, UINT message, 
						  WPARAM wParam, LPARAM lParam)
{
	LRESULT result = FALSE;

	unsigned char facility_buf[(HS_MAX_FAC*2)+1] = {0};
	unsigned char cud[(HS_MAX_CUD*2)+1] = {0};
	int cud_len, fac_len, i, n;
	BOOL tr;

	switch (message)
	{
	case WM_INITDIALOG:
		EnableWindow(GetDlgItem(dlg_main, IDC_BUTTON_CALL), FALSE);

		SetDlgItemText(hDlg, IDC_EDIT_CLD, "1234567");
		SetDlgItemText(hDlg, IDC_EDIT_CLG, "");
		SetDlgItemText(hDlg, IDC_EDIT_CUD, "");
		SetDlgItemText(hDlg, IDC_EDIT_FAC, "");
		SetDlgItemText(hDlg, IDC_EDIT_NCALLS, "1");
				
        CenterWindowInDialog(hDlg);
		return TRUE;

	case WM_COMMAND:
		switch (LOWORD(wParam))
		{
		case IDOK:
			n = (int)GetDlgItemInt(hDlg, IDC_EDIT_NCALLS, &tr, FALSE);

			memset(&conn, 0, sizeof (hs_x25_conn_t));
			
			GetDlgItemText(hDlg, IDC_EDIT_CLD, conn.called, sizeof(conn.called));
			GetDlgItemText(hDlg, IDC_EDIT_CLG, conn.calling, sizeof (conn.calling));
			GetDlgItemText(hDlg, IDC_EDIT_FAC, facility_buf, sizeof (facility_buf));
			GetDlgItemText(hDlg, IDC_EDIT_CUD, cud, sizeof (cud));

			fac_len = strlen(facility_buf);
			cud_len = strlen(cud);

			if (fac_len)
				hexbuf2Bin(facility_buf, conn.facility_buf, fac_len);

			if (cud_len)
				hexbuf2Bin(cud, conn.call_user_data, cud_len);
			
			conn.facility_len = fac_len;
			conn.cud_len = (cud_len / 2);

			conn.dbit = (IsDlgButtonChecked(hDlg, IDC_CHECK_DBIT) == BST_CHECKED) ? 1 : 0;

			for (i=0; i<n; i++)
			{
				if (!rq_put(REQ_CALL, (void *)&conn, sizeof (hs_x25_conn_t)))
					write_event("Failed to submit call request (queue full)");
			}
			/* intentional fall through */

		case IDCANCEL:
			EnableWindow(GetDlgItem(dlg_main, IDC_BUTTON_CALL), TRUE);
			DestroyWindow(hDlg);
			return TRUE;
		}
		break;

	default:
		break;
	}
    return result;
}

static LRESULT CALLBACK DlgWinData(HWND hDlg, UINT message, 
						  WPARAM wParam, LPARAM lParam)
{
	LRESULT result = FALSE;
	int lci, i, n, len, qbit;
	unsigned char *p;
	BOOL translated;
	int sz;
	char fill[2] = {0};

	switch (message)
	{
	case WM_INITDIALOG:
		EnableWindow(GetDlgItem(dlg_main, IDC_BUTTON_DATA), FALSE);				
        CenterWindowInDialog(hDlg);

		if (!ListViewVCGetSelectedLCI(&lci))
		{
			DestroyWindow(hDlg);
			return TRUE;
		}        

		SetDlgItemInt(hDlg, IDC_STATIC_SELCI, lci, FALSE);
		CheckDlgButton(hDlg, IDC_RADIO_SD, BST_CHECKED);
		CheckDlgButton(hDlg, IDC_RADIO_FB, BST_UNCHECKED);
		SetDlgItemText(hDlg, IDC_EDIT_FCHAR, "*");
		SetDlgItemText(hDlg, IDC_EDIT_SD, "ABCDEF");
		SetDlgItemText(hDlg, IDC_EDIT_SIZE, "200");
		SetDlgItemText(hDlg, IDC_EDIT_K, "1");
		return TRUE;

	case WM_CTLCOLORSTATIC:
		if ((HWND)lParam == GetDlgItem(hDlg, IDC_STATIC_SELCI))
		{
			SetTextColor((HDC)wParam, 0);
			SetBkColor  ((HDC)wParam, WHITE);
			result = (long)hbrush1;
		}
		break;

	case WM_COMMAND:
		switch (LOWORD(wParam))
		{
		case IDOK:
			if (!ListViewVCGetSelectedLCI(&lci))
			{
				EnableWindow(GetDlgItem(dlg_main, IDC_BUTTON_DATA), TRUE);
				DestroyWindow(hDlg);
				return TRUE;
			}

			p = malloc(200);
			if (!p)
			{
				EnableWindow(GetDlgItem(dlg_main, IDC_BUTTON_DATA), TRUE);
				DestroyWindow(hDlg);
				return TRUE;
			}

			p = static_str_buf;
			memset(p, 0, sizeof (static_str_buf));
			GetDlgItemText(hDlg, IDC_EDIT_SD, p, 199);
			len = strlen(p);
			n = (int)GetDlgItemInt(hDlg, IDC_EDIT_K, &translated, FALSE);
			qbit = (IsDlgButtonChecked(hDlg, IDC_CHECK_QB) == BST_CHECKED) ? 1 : 0;

			for (i=0; i<n; i++)
				submit_data_req(lci, p, len, qbit, FALSE);
			
			EnableWindow(GetDlgItem(dlg_main, IDC_BUTTON_DATA), TRUE);
			DestroyWindow(hDlg);
			return TRUE;

		case IDOK_BUF:
			if (!ListViewVCGetSelectedLCI(&lci))
			{
				EnableWindow(GetDlgItem(dlg_main, IDC_BUTTON_DATA), TRUE);
				DestroyWindow(hDlg);
				return TRUE;
			}

			sz = (int)GetDlgItemInt(hDlg, IDC_EDIT_SIZE, &translated, FALSE);
			GetDlgItemText(hDlg, IDC_EDIT_FCHAR, &fill[0], 2);
			n = (int)GetDlgItemInt(hDlg, IDC_EDIT_K, &translated, FALSE);
			qbit = (IsDlgButtonChecked(hDlg, IDC_CHECK_QB) == BST_CHECKED) ? 1 : 0;

			for (i=0; i<n; i++)
			{
				p = (unsigned char *)malloc(sz);
				if (!p) break;
				memset(p, fill[0], sz);
				submit_data_req(lci, p, sz, qbit, TRUE);		
			}
			/* intentional fall through */

		case IDCANCEL:
			EnableWindow(GetDlgItem(dlg_main, IDC_BUTTON_DATA), TRUE);
			DestroyWindow(hDlg);
			return TRUE;
		}
		break;

	default:
		break;
	}
    return result;
}


LRESULT CALLBACK DlgWin(HWND hDlg, UINT message, 
						  WPARAM wParam, LPARAM lParam)
{
	LRESULT result = FALSE;
	int rc;
	unsigned char s[80] = {0};
	int lci;

	switch (message)
	{
	case WM_INITDIALOG:
		SetDlgItemInt(hDlg, IDC_STATIC_NVC, num_vcs_up, FALSE);
		CheckDlgButton(hDlg, IDC_RADIO_DTE, BST_CHECKED);

		SetDlgItemText(hDlg, IDC_IPADDRESS1, "127.0.0.1");
        InitComboControl(hDlg, pktsz, IDC_COMBO_PKTSZ, 0);		
        InitComboControl(hDlg, wszs, IDC_COMBO_WSIZE, 1);	
		SetDlgItemText(hDlg, IDC_EDIT_LOCAL_ADDR, "1234567");
		CheckDlgButton(hDlg, IDC_CHECK_ACC_ALL, BST_CHECKED);
		CheckDlgButton(hDlg, IDC_CHECK_ACC_DBIT, BST_CHECKED);

		SetDlgItemInt(hDlg, IDC_EDIT_LO_LCN, low_lcn, FALSE);
		SetDlgItemInt(hDlg, IDC_EDIT_HI_LCN, high_lcn, FALSE);

		InitListView(GetDlgItem(hDlg, IDC_LIST_VC));
		InitListAppView(GetDlgItem(hDlg, IDC_LIST_EV));
		InitListViewTrace(GetDlgItem(hDlg, IDC_LIST_TRACE));

		SendMessage(GetDlgItem(hDlg, IDC_BUTTON_WEB), BM_SETIMAGE, IMAGE_BITMAP, 
				   (LPARAM) LoadBitmap(hInst, MAKEINTRESOURCE(IDB_BITMAP1)));

		SendMessage(GetDlgItem(hDlg, IDC_BUTTON_MANUAL), BM_SETIMAGE, IMAGE_BITMAP, 
				   (LPARAM) LoadBitmap(hInst, MAKEINTRESOURCE(IDB_BITMAP3)));

		SendMessage(GetDlgItem(hDlg, IDC_BUTTON_ORDER), BM_SETIMAGE, IMAGE_BITMAP, 
				   (LPARAM) LoadBitmap(hInst, MAKEINTRESOURCE(IDB_BITMAP2)));

		dlg_main = hDlg;

		write_event("*** HsX25 1.2 Demo Application ***");

		initialise_x25(hDlg);
		return TRUE;

	case WM_CTLCOLORSTATIC:
		if (((HWND)lParam == GetDlgItem(hDlg, IDC_STATIC_VCS)) ||
			((HWND)lParam == GetDlgItem(hDlg, IDC_STATIC_NVC)) ||
			((HWND)lParam == GetDlgItem(hDlg, IDC_STATIC_SLCI)) ||
			((HWND)lParam == GetDlgItem(hDlg, IDC_STATIC_SRES_TX)) ||
			((HWND)lParam == GetDlgItem(hDlg, IDC_STATIC_SRES_RX)) ||
			((HWND)lParam == GetDlgItem(hDlg, IDC_STATIC_SDRX)) ||
			((HWND)lParam == GetDlgItem(hDlg, IDC_STATIC_SDTX)) ||
			((HWND)lParam == GetDlgItem(hDlg, IDC_STATIC_SWIN)) ||
			((HWND)lParam == GetDlgItem(hDlg, IDC_STATIC_CFG)) ||
			((HWND)lParam == GetDlgItem(hDlg, IDC_STATIC_SEVL)) ||
			((HWND)lParam == GetDlgItem(hDlg, IDC_STATIC_SCMD)) ||
			((HWND)lParam == GetDlgItem(hDlg, IDC_STATIC_VC_STATS)))
		{
			SetTextColor((HDC)wParam, 0);
			SetBkColor  ((HDC)wParam, WHITE);
			result = (long)hbrush1;
		}
		break;

	case WM_COMMAND:
		switch (LOWORD(wParam))
		{
		case IDC_BUTTON_NOLIS:
			rc = HsX25FlushListenQueue(0xffff);
			
			sprintf(s, "Flush listen queue %s (rc %d)", (rc == HS_X25_RC_OK) ? "Ok" : "Fail", rc);
			write_event(s);
			break;

		case IDC_BUTTON_CALL:
			NewDialogWin(hInst, hwnd_main, DlgWinCall, IDD_DIALOG_CALL);
			break;

		case IDC_BUTTON_DATA:
			if (!ListViewVCGetSelectedLCI(&lci))
				break;
			
			NewDialogWin(hInst, hwnd_main, DlgWinData, IDD_DIALOG_DATA);
			break;

		case IDC_BUTTON_CFG:
			if (app_timer)
			{
				KillTimer(0, (UINT_PTR)app_timer);
				app_timer = 0;
			}
			
			HsX25ShutDown();

			initialise_x25(hDlg);
			break;

		case IDC_BUTTON_CLR_TRC:
			ListView_DeleteAllItems(GetDlgItem(hDlg, IDC_LIST_TRACE));
			pkttrace_len = 0;
			break;

		case IDC_BUTTON_DISC:
			if (!ListViewVCGetSelectedLCI(&lci))
				break;

			sprintf(s, "Clearing call LCI %d", lci);
			write_event(s);
			
			HsX25Clear(vclist[lci].vchan);
			
			ListViewVCDeleteCall(lci);
			break;
		}		
		break;
	}
    return result;
}

/*
 * Main window message handler
 */
LRESULT CALLBACK WndProc(HWND		hWnd, 
						 UINT		message, 
						 WPARAM		wParam, 
						 LPARAM		lParam)
{
	static INITCOMMONCONTROLSEX icex;

	switch (message) 
	{
	case WM_CREATE:
		icex.dwSize = sizeof(icex);
		icex.dwICC = ICC_DATE_CLASSES;

		InitCommonControlsEx(&icex);

		InitCommonControls(); 

		dlg_main = NewDialogWin(hInst, hWnd, DlgWin, IDD_DIALOG_MAIN);
		break;

	case WM_MOVE:
		break;

	case WM_DESTROY:
		if (hbrush1)
		{
			SelectObject(GetWindowDC(hWnd), hbrush1);
			DeleteObject(hbrush1);
		}

		if (app_timer)
			KillTimer(0, (UINT_PTR)app_timer);

		HsX25ShutDown();

		PostQuitMessage(0);
		break;

	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
   
	return 0;
}

/*
 * Init Application Instance
 */
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow, HWND *hwnd)
{
	HWND hWnd;

	hInst = hInstance;

	hWnd = CreateWindow(szWindowClass, 
					   szTitle, 
					   WS_OVERLAPPED | WS_SYSMENU,
					   0, 
					   0, 
					   MAINWIDTH,
					   MAINDEPTH, 
					   NULL, LoadMenu(hInstance, (LPCTSTR)0), 
					   hInstance, NULL);

	if (!hWnd)
	{
		return FALSE;
	}
	*hwnd = hWnd;

	ShowWindow(hWnd, nCmdShow);
	UpdateWindow(hWnd);

	return TRUE;
}


/*
 * entry point
 */
int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
	MSG		msg;
	HACCEL	hAccelTable;

	hbrush1 = CreateSolidBrush(RGB(255, 255, 255));

	BlRegisterClass(hInstance, CS_HREDRAW | CS_VREDRAW, WndProc, (int)IDC_ARROW,
				   (HBRUSH)(COLOR_APPWORKSPACE+1), szWindowClass, IDI_ICON1, 0);

	if (!InitInstance (hInstance, nCmdShow, &hwnd_main)) 
	{
		return FALSE;
	}

	hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)0);

	while (GetMessage(&msg, NULL, 0, 0)) 
	{
		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}
  
	return msg.wParam;	
}