private int EnableControl(int nDeviceType, int nChannel, bool bEnable, int nTimeout)
{
int nRtn = BSSDK.BS_SUCCESS;
switch (nDeviceType)
{
case BSSDK.BS_DEVICE_BIOSTATION:
case BSSDK.BS_DEVICE_BIOLITE:
case BSSDK.BS_DEVICE_DSTATION:
case BSSDK.BS_DEVICE_XSTATION:
case BSSDK.BS_DEVICE_BIOSTATION2:
{
for (int nIndex = 0; nIndex < 2; nIndex++)
{
nRtn = bEnable ? BSSDK.BS_Enable(nChannel) : BSSDK.BS_Disable(nChannel, nTimeout);
if (nRtn == BSSDK.BS_SUCCESS)
{
break;
}
//Sleep(50);
}
}
break;
default:
break;
}
return(nRtn);
}
private void LogManagement_Load(object sender, EventArgs e)
{
if (m_DeviceType == BSSDK.BS_DEVICE_BEPLUS)
{
deviceInfo.Text = "BioEntry Plus " + m_DeviceID.ToString();
}
else if (m_DeviceType == BSSDK.BS_DEVICE_BIOLITE)
{
deviceInfo.Text = "BioLite Net " + m_DeviceID.ToString();
}
else
{
deviceInfo.Text = "BioStation " + m_DeviceID.ToString();
}
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_GetLogCount(m_Handle, ref m_NumOfLog);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot read log count", "Error");
return;
}
numOfLog.Text = m_NumOfLog.ToString();
}
private void deleteButton_Click(object sender, EventArgs e)
{
if (userList.SelectedItems.Count == 0)
{
MessageBox.Show("Please select a user first", "Error");
return;
}
uint ID = 0;
try
{
ID = UInt32.Parse(userList.SelectedItems[0].Text);
}
catch (Exception)
{
MessageBox.Show("Invalid ID", "Error");
return;
}
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_DeleteUser(m_Handle, ID);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot delete the user", "Error");
return;
}
ReadUserInfo();
}
private void ReadLog2()
{
IntPtr logRecord = Marshal.AllocHGlobal(m_NumOfLog * Marshal.SizeOf(typeof(BSSDK.BSLogRecordEx)));
int logTotalCount = 0;
int logCount = 0;
do
{
Cursor.Current = Cursors.WaitCursor;
int result = 0;
IntPtr buf = new IntPtr(logRecord.ToInt32() + logTotalCount * Marshal.SizeOf(typeof(BSSDK.BSLogRecordEx)));
if (logTotalCount == 0)
{
result = BSSDK.BS_ReadLogEx(m_Handle, 0, 0, ref logCount, buf);
}
else
{
result = BSSDK.BS_ReadNextLogEx(m_Handle, 0, 0, ref logCount, buf);
}
if (result != BSSDK.BS_SUCCESS)
{
Marshal.FreeHGlobal(logRecord);
MessageBox.Show("Cannot read log records", "Error");
Cursor.Current = Cursors.WaitCursor;
return;
}
logTotalCount += logCount;
} while (logCount == 8192);
Cursor.Current = Cursors.WaitCursor;
logList.Items.Clear();
for (int i = 0; i < logTotalCount; i++)
{
BSSDK.BSLogRecordEx record = (BSSDK.BSLogRecordEx)Marshal.PtrToStructure(new IntPtr(logRecord.ToInt32() + i * Marshal.SizeOf(typeof(BSSDK.BSLogRecordEx))), typeof(BSSDK.BSLogRecordEx));
DateTime eventTime = new DateTime(1970, 1, 1).AddSeconds(record.eventTime);
ListViewItem item = logList.Items.Add(eventTime.ToString());
item.SubItems.Add(record.userID.ToString());
item.SubItems.Add(GetEventStr(record.eventType));
item.SubItems.Add(GetTNAStr(record.tnaEvent));
item.SubItems.Add(GetReaderID(record.deviceID));
item.SubItems.Add(record.eventType.ToString());
item.SubItems.Add(record.eventTime.ToString());
}
numOfLog.Text = logTotalCount.ToString();
Marshal.FreeHGlobal(logRecord);
}
private void userTest_Click(object sender, EventArgs e)
{
if (connectedDeviceList.SelectedIndex < 0)
{
MessageBox.Show("Select a connected device first", "Error");
return;
}
BSSDK.BS_SetDeviceID(m_ConnectedDeviceHandle[connectedDeviceList.SelectedIndex],
m_ConnectedDeviceID[connectedDeviceList.SelectedIndex], m_ConnectedDeviceType[connectedDeviceList.SelectedIndex]);
// BSSDK.BSOPModeConfig OPModeCongif = new BSSDK.BSOPModeConfig();
// IntPtr sysInfo = Marshal.AllocHGlobal(Marshal.SizeOf(OPModeCongif));
//CALLING FUNCTION
// int result = BSSDK.BS_ReadOPModeConfig(m_ConnectedDeviceHandle[connectedDeviceList.SelectedIndex], sysInfo);
UserManagement userTest = new UserManagement();
userTest.SetDevice(m_ConnectedDeviceHandle[connectedDeviceList.SelectedIndex],
m_ConnectedDeviceID[connectedDeviceList.SelectedIndex], m_ConnectedDeviceType[connectedDeviceList.SelectedIndex]);
userTest.Show();
}
private void readImageLogButton_Click(object sender, EventArgs e)
{
if (m_DeviceType != BSSDK.BS_DEVICE_DSTATION && m_DeviceType != BSSDK.BS_DEVICE_XSTATION && m_DeviceType != BSSDK.BS_DEVICE_BIOSTATION2)
{
return; // Not Supported.
}
Cursor.Current = Cursors.WaitCursor;
byte[] imageLog = new byte[Marshal.SizeOf(typeof(BSSDK.BSImageLogHdr)) + BSSDK.DF_LEN_MAX_IMAGE];
int dataLen = 0, eventTime = 0, eventType = 0;
for (int i = 0; i < logList.Items.Count; i++)
{
if (logList.Items[i].Selected == true)
{
eventType = (int)System.Convert.ToDecimal(logList.Items[i].SubItems[5].Text);
eventTime = (int)System.Convert.ToDecimal(logList.Items[i].SubItems[6].Text);
break;
}
}
int result = BSSDK.BS_ReadSpecificImageLog(m_Handle, eventTime, eventType, ref dataLen, imageLog);
if (dataLen > Marshal.SizeOf(typeof(BSSDK.BSImageLogHdr)))
{
GCHandle packet = GCHandle.Alloc(imageLog, GCHandleType.Pinned);
BSSDK.BSImageLogHdr imageHdr = (BSSDK.BSImageLogHdr)Marshal.PtrToStructure(packet.AddrOfPinnedObject(), typeof(BSSDK.BSImageLogHdr));
int imageSize = (int)imageHdr.imageSize;
packet.Free();
if (imageSize > 0 && imageSize < BSSDK.DF_LEN_MAX_IMAGE)
{
byte[] imageBytes = new byte[imageSize];
System.Buffer.BlockCopy(imageLog, Marshal.SizeOf(typeof(BSSDK.BSImageLogHdr)), imageBytes, 0, imageBytes.Length);
try
{
String filename = "c:\\temp\\test.jpg";
FileStream fs = new FileStream(filename, FileMode.CreateNew, FileAccess.ReadWrite);
BinaryWriter write_fs = new BinaryWriter(fs);
write_fs.Write(imageBytes);
write_fs.Close();
fs.Close();
pictureBox1.Image = System.Drawing.Bitmap.FromFile(filename);
}
catch (Exception saveE)
{
MessageBox.Show(this, saveE.Message);
}
}
}
Cursor.Current = Cursors.Default;
}
private void clearButton_Click(object sender, EventArgs e)
{
for (int i = 0; i < m_NumOfConnectedDevice; i++)
{
BSSDK.BS_CloseSocket(m_ConnectedDeviceHandle[i]);
}
m_NumOfConnectedDevice = 0;
connectedDeviceList.Items.Clear();
}
private void searchButton_Click(object sender, EventArgs e)
{
deviceList.Items.Clear();
Cursor.Current = Cursors.WaitCursor;
int result;
try
{
result = BSSDK.BS_SearchDeviceInLAN(m_Handle, ref m_NumOfDevice, m_DeviceID, m_DeviceType, m_DeviceAddr);
}
finally
{
Cursor.Current = Cursors.Default;
}
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot find any device", "Error");
return;
}
for (int i = 0; i < m_NumOfDevice; i++)
{
string device = "";
if (m_DeviceType[i] == BSSDK.BS_DEVICE_BIOSTATION)
{
device += "BioStation ";
}
else if (m_DeviceType[i] == BSSDK.BS_DEVICE_BEPLUS)
{
device += "BioEntry Plus ";
}
else
{
device += "BioLite Net ";
}
device += (m_DeviceAddr[i] & 0xff) + ".";
device += ((m_DeviceAddr[i] >> 8) & 0xff) + ".";
device += ((m_DeviceAddr[i] >> 16) & 0xff) + ".";
device += ((m_DeviceAddr[i] >> 24) & 0xff);
device += "(" + m_DeviceID[i] + ")";
deviceList.Items.Add(device);
}
}
private void deleteAllButton_Click(object sender, EventArgs e)
{
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_DeleteAllUser(m_Handle);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot delete all users", "Error");
return;
}
ReadUserInfo();
}
private void setTime_Click(object sender, EventArgs e)
{
int localTime = (int)((timePicker.Value.Ticks - new DateTime(1970, 1, 1).Ticks) / 10000000);
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_SetTime(m_Handle, localTime);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot set the time", "Error");
return;
}
}
private void timeTest_Click(object sender, EventArgs e)
{
if (connectedDeviceList.SelectedIndex < 0)
{
MessageBox.Show("Select a connected device first", "Error");
return;
}
BSSDK.BS_SetDeviceID(m_ConnectedDeviceHandle[connectedDeviceList.SelectedIndex],
m_ConnectedDeviceID[connectedDeviceList.SelectedIndex], m_ConnectedDeviceType[connectedDeviceList.SelectedIndex]);
SetupTime setupTime = new SetupTime();
setupTime.setHandle(m_ConnectedDeviceHandle[connectedDeviceList.SelectedIndex]);
setupTime.Show();
}
private void BioStar_Load(object sender, EventArgs e)
{
int result = BSSDK.BS_InitSDK();
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot initialize the SDK", "Error");
return;
}
result = BSSDK.BS_OpenInternalUDP(ref m_Handle);
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot open internal UDP socket", "Error");
return;
}
}
private void userTest_Click(object sender, EventArgs e)
{
if (connectedDeviceList.SelectedIndex < 0)
{
MessageBox.Show("Select a connected device first", "Error");
return;
}
BSSDK.BS_SetDeviceID(m_ConnectedDeviceHandle[connectedDeviceList.SelectedIndex],
m_ConnectedDeviceID[connectedDeviceList.SelectedIndex], m_ConnectedDeviceType[connectedDeviceList.SelectedIndex]);
UserManagement userTest = new UserManagement();
userTest.SetDevice(m_ConnectedDeviceHandle[connectedDeviceList.SelectedIndex],
m_ConnectedDeviceID[connectedDeviceList.SelectedIndex], m_ConnectedDeviceType[connectedDeviceList.SelectedIndex]);
userTest.Show();
}
private void deleteAllButton_Click(object sender, EventArgs e)
{
Cursor.Current = Cursors.WaitCursor;
int deletedCount = 0;
int result = BSSDK.BS_DeleteLog(m_Handle, 0, ref deletedCount);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot delete log records", "Error");
return;
}
numOfLog.Text = "0";
logList.Items.Clear();
}
private void getTime_Click(object sender, EventArgs e)
{
int localTime = 0;
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_GetTime(m_Handle, ref localTime);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot get the time", "Error");
return;
}
datePicker.Value = new DateTime(1970, 1, 1).AddSeconds(localTime);
timePicker.Value = datePicker.Value;
}
private void connect_Click(object sender, EventArgs e)
{
IPAddress addr = new IPAddress(m_DeviceAddr);
int handle = 0;
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_OpenSocket(addr.ToString(), Int32.Parse(port.Text), ref handle);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot connect to the device", "Error");
return;
}
m_MainForm.AddConnectedDevice(m_DeviceID, m_DeviceType, m_DeviceAddr, handle);
}
private void readCard_Click(object sender, EventArgs e)
{
uint card_id = 0;
int custom_id = 0;
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_ReadCardIDEx(m_Handle, ref card_id, ref custom_id);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot read the card", "Error");
return;
}
userCardID.Text = card_id.ToString("X");
cardCustomID.Text = custom_id.ToString();
}
private bool ReadConfig()
{
int configSize = 0;
Cursor.Current = Cursors.WaitCursor;
if (m_DeviceType == BSSDK.BS_DEVICE_BEPLUS || m_DeviceType == BSSDK.BS_DEVICE_XPASS)
{
IntPtr config = Marshal.AllocHGlobal(Marshal.SizeOf(m_ConfigBEPlus));
int result = BSSDK.BS_ReadConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BEPLUS_CONFIG, ref configSize, config);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot read the configuration", "Error");
Marshal.FreeHGlobal(config);
return(false);
}
m_ConfigBEPlus = (BSSDK.BEConfigData)Marshal.PtrToStructure(config, typeof(BSSDK.BEConfigData));
Marshal.FreeHGlobal(config);
DHCP.Checked = m_ConfigBEPlus.useDHCP;
useServer.Checked = m_ConfigBEPlus.useServer;
synchTime.Checked = m_ConfigBEPlus.synchTime;
IPAddress addr = new IPAddress(m_ConfigBEPlus.ipAddr);
ipAddr.Text = addr.ToString();
addr.Address = m_ConfigBEPlus.gateway;
gateway.Text = addr.ToString();
addr.Address = m_ConfigBEPlus.subnetMask;
subnetMask.Text = addr.ToString();
addr.Address = m_ConfigBEPlus.serverIpAddr;
serverIP.Text = addr.ToString();
port.Text = m_ConfigBEPlus.port.ToString();
if (DHCP.Checked)
{
ipAddr.Enabled = false;
gateway.Enabled = false;
subnetMask.Enabled = false;
}
else
{
ipAddr.Enabled = true;
gateway.Enabled = true;
subnetMask.Enabled = true;
}
}
else if (m_DeviceType == BSSDK.BS_DEVICE_BIOLITE)
{
IntPtr config = Marshal.AllocHGlobal(Marshal.SizeOf(m_ConfigBLN));
int result = BSSDK.BS_ReadConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BLN_CONFIG, ref configSize, config);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot read the configuration", "Error");
Marshal.FreeHGlobal(config);
return(false);
}
m_ConfigBLN = (BSSDK.BEConfigDataBLN)Marshal.PtrToStructure(config, typeof(BSSDK.BEConfigDataBLN));
Marshal.FreeHGlobal(config);
DHCP.Checked = m_ConfigBLN.useDHCP;
useServer.Checked = m_ConfigBLN.useServer;
synchTime.Checked = m_ConfigBLN.synchTime;
IPAddress addr = new IPAddress(m_ConfigBLN.ipAddr);
ipAddr.Text = addr.ToString();
addr.Address = m_ConfigBLN.gateway;
gateway.Text = addr.ToString();
addr.Address = m_ConfigBLN.subnetMask;
subnetMask.Text = addr.ToString();
addr.Address = m_ConfigBLN.serverIpAddr;
serverIP.Text = addr.ToString();
port.Text = m_ConfigBLN.port.ToString();
if (DHCP.Checked)
{
ipAddr.Enabled = false;
gateway.Enabled = false;
subnetMask.Enabled = false;
}
else
{
ipAddr.Enabled = true;
gateway.Enabled = true;
subnetMask.Enabled = true;
}
}
else if (m_DeviceType == BSSDK.BS_DEVICE_BIOSTATION)
{
IntPtr config = Marshal.AllocHGlobal(Marshal.SizeOf(m_ConfigBST));
int result = BSSDK.BS_ReadConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BS_CONFIG_TCPIP, ref configSize, config);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot read the configuration", "Error");
Marshal.FreeHGlobal(config);
return(false);
}
m_ConfigBST = (BSSDK.BSIPConfig)Marshal.PtrToStructure(config, typeof(BSSDK.BSIPConfig));
Marshal.FreeHGlobal(config);
DHCP.Checked = m_ConfigBST.useDHCP;
useServer.Checked = m_ConfigBST.useServer;
synchTime.Checked = m_ConfigBST.syncTimeWithServer;
ipAddr.Text = Encoding.ASCII.GetString(m_ConfigBST.ipAddr);
gateway.Text = Encoding.ASCII.GetString(m_ConfigBST.gateway);
subnetMask.Text = Encoding.ASCII.GetString(m_ConfigBST.subnetMask);
serverIP.Text = Encoding.ASCII.GetString(m_ConfigBST.serverIP);
if (m_ConfigBST.useServer)
{
port.Text = m_ConfigBST.serverPort.ToString();
}
else
{
port.Text = m_ConfigBST.port.ToString();
}
if (DHCP.Checked)
{
ipAddr.Enabled = false;
gateway.Enabled = false;
subnetMask.Enabled = false;
}
else
{
ipAddr.Enabled = true;
gateway.Enabled = true;
subnetMask.Enabled = true;
}
}
else if (m_DeviceType == BSSDK.BS_DEVICE_DSTATION)
{
IntPtr config = Marshal.AllocHGlobal(Marshal.SizeOf(m_ConfigBST));
int result = BSSDK.BS_ReadConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BS_CONFIG_TCPIP, ref configSize, config);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot read the configuration", "Error");
Marshal.FreeHGlobal(config);
return(false);
}
m_ConfigBST = (BSSDK.BSIPConfig)Marshal.PtrToStructure(config, typeof(BSSDK.BSIPConfig));
Marshal.FreeHGlobal(config);
DHCP.Checked = m_ConfigBST.useDHCP;
useServer.Checked = m_ConfigBST.useServer;
synchTime.Checked = m_ConfigBST.syncTimeWithServer;
ipAddr.Text = Encoding.ASCII.GetString(m_ConfigBST.ipAddr);
gateway.Text = Encoding.ASCII.GetString(m_ConfigBST.gateway);
subnetMask.Text = Encoding.ASCII.GetString(m_ConfigBST.subnetMask);
serverIP.Text = Encoding.ASCII.GetString(m_ConfigBST.serverIP);
if (m_ConfigBST.useServer)
{
port.Text = m_ConfigBST.serverPort.ToString();
}
else
{
port.Text = m_ConfigBST.port.ToString();
}
if (DHCP.Checked)
{
ipAddr.Enabled = false;
gateway.Enabled = false;
subnetMask.Enabled = false;
}
else
{
ipAddr.Enabled = true;
gateway.Enabled = true;
subnetMask.Enabled = true;
}
}
else if (m_DeviceType == BSSDK.BS_DEVICE_XSTATION || m_DeviceType == BSSDK.BS_DEVICE_BIOSTATION2)
{
IntPtr config = Marshal.AllocHGlobal(Marshal.SizeOf(m_ConfigBST));
int result = BSSDK.BS_ReadConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BS_CONFIG_TCPIP, ref configSize, config);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot read the configuration", "Error");
Marshal.FreeHGlobal(config);
return(false);
}
m_ConfigBST = (BSSDK.BSIPConfig)Marshal.PtrToStructure(config, typeof(BSSDK.BSIPConfig));
Marshal.FreeHGlobal(config);
DHCP.Checked = m_ConfigBST.useDHCP;
useServer.Checked = m_ConfigBST.useServer;
synchTime.Checked = m_ConfigBST.syncTimeWithServer;
ipAddr.Text = Encoding.ASCII.GetString(m_ConfigBST.ipAddr);
gateway.Text = Encoding.ASCII.GetString(m_ConfigBST.gateway);
subnetMask.Text = Encoding.ASCII.GetString(m_ConfigBST.subnetMask);
serverIP.Text = Encoding.ASCII.GetString(m_ConfigBST.serverIP);
if (m_ConfigBST.useServer)
{
port.Text = m_ConfigBST.serverPort.ToString();
}
else
{
port.Text = m_ConfigBST.port.ToString();
}
if (DHCP.Checked)
{
ipAddr.Enabled = false;
gateway.Enabled = false;
subnetMask.Enabled = false;
}
else
{
ipAddr.Enabled = true;
gateway.Enabled = true;
subnetMask.Enabled = true;
}
}
return(true);
}
private bool ReadSysInfo()
{
int configSize = 0;
Cursor.Current = Cursors.WaitCursor;
if (m_DeviceType == BSSDK.BS_DEVICE_BEPLUS || m_DeviceType == BSSDK.BS_DEVICE_XPASS)
{
IntPtr sysInfo = Marshal.AllocHGlobal(Marshal.SizeOf(m_SysInfoBEPlus));
int result = BSSDK.BS_ReadConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BEPLUS_CONFIG_SYS_INFO, ref configSize, sysInfo);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot read the sys info", "Error");
Marshal.FreeHGlobal(sysInfo);
return(false);
}
m_SysInfoBEPlus = (BSSDK.BESysInfoData)Marshal.PtrToStructure(sysInfo, typeof(BSSDK.BESysInfoData));
Marshal.FreeHGlobal(sysInfo);
deviceID.Text = String.Format("{0}", m_SysInfoBEPlus.ID);
MAC.Text = "";
int i = 0;
for (i = 0; i < 5; i++)
{
MAC.Text += m_SysInfoBEPlus.macAddr[i].ToString("X2") + ":";
}
MAC.Text += m_SysInfoBEPlus.macAddr[i].ToString("X2");
FWVersion.Text = Encoding.ASCII.GetString(m_SysInfoBEPlus.firmwareVer);
}
else if (m_DeviceType == BSSDK.BS_DEVICE_BIOLITE)
{
IntPtr sysInfo = Marshal.AllocHGlobal(Marshal.SizeOf(m_SysInfoBLN));
int result = BSSDK.BS_ReadConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BLN_CONFIG_SYS_INFO, ref configSize, sysInfo);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot read the sys info", "Error");
Marshal.FreeHGlobal(sysInfo);
return(false);
}
m_SysInfoBLN = (BSSDK.BESysInfoDataBLN)Marshal.PtrToStructure(sysInfo, typeof(BSSDK.BESysInfoDataBLN));
Marshal.FreeHGlobal(sysInfo);
deviceID.Text = String.Format("{0}", m_SysInfoBLN.ID);
MAC.Text = "";
int i = 0;
for (i = 0; i < 5; i++)
{
MAC.Text += m_SysInfoBLN.macAddr[i].ToString("X2") + ":";
}
MAC.Text += m_SysInfoBLN.macAddr[i].ToString("X2");
FWVersion.Text = Encoding.ASCII.GetString(m_SysInfoBLN.firmwareVer);
}
else if (m_DeviceType == BSSDK.BS_DEVICE_BIOSTATION)
{
IntPtr sysInfo = Marshal.AllocHGlobal(Marshal.SizeOf(m_SysInfoBST));
int result = BSSDK.BS_ReadConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BS_CONFIG_SYS_INFO, ref configSize, sysInfo);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot read the sys info", "Error");
Marshal.FreeHGlobal(sysInfo);
return(false);
}
m_SysInfoBST = (BSSDK.BSSysInfoConfig)Marshal.PtrToStructure(sysInfo, typeof(BSSDK.BSSysInfoConfig));
Marshal.FreeHGlobal(sysInfo);
deviceID.Text = String.Format("{0}", m_SysInfoBST.ID);
MAC.Text = Encoding.ASCII.GetString(m_SysInfoBST.macAddr);
FWVersion.Text = Encoding.ASCII.GetString(m_SysInfoBST.firmwareVer);
}
else if (m_DeviceType == BSSDK.BS_DEVICE_DSTATION)
{
IntPtr sysInfo = Marshal.AllocHGlobal(Marshal.SizeOf(m_SysInfoBST));
int result = BSSDK.BS_ReadConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BS_CONFIG_SYS_INFO, ref configSize, sysInfo);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot read the sys info", "Error");
Marshal.FreeHGlobal(sysInfo);
return(false);
}
m_SysInfoBST = (BSSDK.BSSysInfoConfig)Marshal.PtrToStructure(sysInfo, typeof(BSSDK.BSSysInfoConfig));
Marshal.FreeHGlobal(sysInfo);
deviceID.Text = String.Format("{0}", m_SysInfoBST.ID);
MAC.Text = Encoding.ASCII.GetString(m_SysInfoBST.macAddr);
FWVersion.Text = Encoding.ASCII.GetString(m_SysInfoBST.firmwareVer);
}
else if (m_DeviceType == BSSDK.BS_DEVICE_XSTATION)
{
IntPtr sysInfo = Marshal.AllocHGlobal(Marshal.SizeOf(m_SysInfoBST));
int result = BSSDK.BS_ReadConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BS_CONFIG_SYS_INFO, ref configSize, sysInfo);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot read the sys info", "Error");
Marshal.FreeHGlobal(sysInfo);
return(false);
}
m_SysInfoBST = (BSSDK.BSSysInfoConfig)Marshal.PtrToStructure(sysInfo, typeof(BSSDK.BSSysInfoConfig));
Marshal.FreeHGlobal(sysInfo);
deviceID.Text = String.Format("{0}", m_SysInfoBST.ID);
MAC.Text = Encoding.ASCII.GetString(m_SysInfoBST.macAddr);
FWVersion.Text = Encoding.ASCII.GetString(m_SysInfoBST.firmwareVer);
}
else if (m_DeviceType == BSSDK.BS_DEVICE_BIOSTATION2)
{
IntPtr sysInfo = Marshal.AllocHGlobal(Marshal.SizeOf(m_SysInfoBST));
int result = BSSDK.BS_ReadConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BS_CONFIG_SYS_INFO, ref configSize, sysInfo);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot read the sys info", "Error");
Marshal.FreeHGlobal(sysInfo);
return(false);
}
m_SysInfoBST = (BSSDK.BSSysInfoConfig)Marshal.PtrToStructure(sysInfo, typeof(BSSDK.BSSysInfoConfig));
Marshal.FreeHGlobal(sysInfo);
deviceID.Text = String.Format("{0}", m_SysInfoBST.ID);
MAC.Text = Encoding.ASCII.GetString(m_SysInfoBST.macAddr);
FWVersion.Text = Encoding.ASCII.GetString(m_SysInfoBST.firmwareVer);
}
return(true);
}
private void addUser_Click(object sender, EventArgs e)
{
if (userID.Text.Length == 0)
{
MessageBox.Show("Enter user ID first", "Error");
return;
}
uint ID = 0;
try
{
ID = UInt32.Parse(userID.Text);
}
catch (Exception)
{
MessageBox.Show("Invalid ID", "Error");
return;
}
int result = 0;
int fingerChecksum1 = 0;
int fingerChecksum2 = 0;
byte[] templateData = new byte[TEMPLATE_SIZE];
int numOfFinger = 0;
if (finger1.Checked)
{
numOfFinger++;
Cursor.Current = Cursors.WaitCursor;
result = BSSDK.BS_ScanTemplate(m_Handle, templateData);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot scan the finger", "Error");
return;
}
Buffer.BlockCopy(templateData, 0, m_TemplateData, 0, TEMPLATE_SIZE);
Cursor.Current = Cursors.WaitCursor;
result = BSSDK.BS_ScanTemplate(m_Handle, templateData);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot scan the finger", "Error");
return;
}
Buffer.BlockCopy(templateData, 0, m_TemplateData, TEMPLATE_SIZE, TEMPLATE_SIZE);
for (int i = 0; i < TEMPLATE_SIZE * 2; i++)
{
fingerChecksum1 += m_TemplateData[i];
}
checksum1.Text = fingerChecksum1.ToString();
if (finger2.Checked)
{
numOfFinger++;
Cursor.Current = Cursors.WaitCursor;
result = BSSDK.BS_ScanTemplate(m_Handle, templateData);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot scan the finger", "Error");
return;
}
Buffer.BlockCopy(templateData, 0, m_TemplateData, TEMPLATE_SIZE * 2, TEMPLATE_SIZE);
Cursor.Current = Cursors.WaitCursor;
result = BSSDK.BS_ScanTemplate(m_Handle, templateData);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot scan the finger", "Error");
return;
}
Buffer.BlockCopy(templateData, 0, m_TemplateData, TEMPLATE_SIZE * 3, TEMPLATE_SIZE);
for (int i = 0; i < TEMPLATE_SIZE * 2; i++)
{
fingerChecksum2 += m_TemplateData[TEMPLATE_SIZE * 2 + i];
}
checksum2.Text = fingerChecksum2.ToString();
}
}
if (m_DeviceType == BSSDK.BS_DEVICE_BEPLUS || m_DeviceType == BSSDK.BS_DEVICE_BIOLITE)
{
BSSDK.BEUserHdr userHdr = new BSSDK.BEUserHdr();
userHdr.fingerChecksum = new ushort[2];
userHdr.isDuress = new byte[2];
userHdr.numOfFinger = (ushort)numOfFinger;
userHdr.fingerChecksum[0] = (ushort)fingerChecksum1;
userHdr.fingerChecksum[1] = (ushort)fingerChecksum2;
userHdr.userID = ID;
userHdr.adminLevel = (ushort)userLevel.SelectedIndex;
userHdr.securityLevel = (ushort)securityLevel.SelectedIndex;
userHdr.cardFlag = (byte)cardType.SelectedIndex;
userHdr.startTime = (int)((startDate.Value.Ticks - new DateTime(1970, 1, 1).Ticks) / 10000000);
userHdr.expiryTime = (int)((expiryDate.Value.Ticks - new DateTime(1970, 1, 1).Ticks) / 10000000);
userHdr.isDuress[0] = (duress1.Checked) ? (byte)1 : (byte)0;
userHdr.isDuress[1] = (duress2.Checked) ? (byte)1 : (byte)0;
userHdr.opMode = (ushort)authMode.SelectedIndex;
try
{
userHdr.cardID = UInt32.Parse(userCardID.Text, System.Globalization.NumberStyles.HexNumber);
}
catch (Exception)
{
userHdr.cardID = 0;
}
try
{
userHdr.cardCustomID = (byte)Int32.Parse(cardCustomID.Text);
}
catch (Exception)
{
userHdr.cardCustomID = 0;
}
userHdr.cardVersion = BSSDK.BE_CARD_VERSION_1;
userHdr.disabled = 0;
userHdr.dualMode = 0;
try
{
userHdr.accessGroupMask = UInt32.Parse(accessGroup.Text, System.Globalization.NumberStyles.HexNumber);
}
catch (Exception)
{
userHdr.accessGroupMask = 0xffffffff;
}
IntPtr userInfo = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(BSSDK.BEUserHdr)));
Marshal.StructureToPtr(userHdr, userInfo, true);
Cursor.Current = Cursors.WaitCursor;
result = BSSDK.BS_EnrollUserBEPlus(m_Handle, userInfo, m_TemplateData);
Cursor.Current = Cursors.Default;
Marshal.FreeHGlobal(userInfo);
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot enroll the user", "Error");
return;
}
ReadUserInfo();
}
else if (m_DeviceType == BSSDK.BS_DEVICE_BIOSTATION)
{
BSSDK.BSUserHdrEx userHdr = new BSSDK.BSUserHdrEx();
userHdr.checksum = new ushort[5];
userHdr.name = new byte[33];
userHdr.department = new byte[33];
userHdr.password = new byte[17];
userHdr.authLimitCount = 0;
userHdr.timedAntiPassback = 0;
userHdr.disabled = 0;
userHdr.numOfFinger = (ushort)numOfFinger;
userHdr.checksum[0] = (ushort)fingerChecksum1;
userHdr.checksum[1] = (ushort)fingerChecksum2;
userHdr.ID = ID;
userHdr.adminLevel = (ushort)((userLevel.SelectedIndex == 1) ? BSSDK.BS_USER_ADMIN : BSSDK.BS_USER_NORMAL);
userHdr.securityLevel = (ushort)(securityLevel.SelectedIndex + BSSDK.BS_USER_SECURITY_DEFAULT);
userHdr.bypassCard = (byte)cardType.SelectedIndex;
userHdr.startDateTime = (uint)((startDate.Value.Ticks - new DateTime(1970, 1, 1).Ticks) / 10000000);
userHdr.expireDateTime = (uint)((expiryDate.Value.Ticks - new DateTime(1970, 1, 1).Ticks) / 10000000);
userHdr.duressMask = 0;
if (duress1.Checked)
{
userHdr.duressMask |= 0x01;
}
if (duress2.Checked)
{
userHdr.duressMask |= 0x02;
}
if (authMode.SelectedIndex == 0)
{
userHdr.authMode = 0;
}
else
{
userHdr.authMode = (ushort)(authMode.SelectedIndex + BSSDK.BS_AUTH_FINGER_ONLY - 1);
}
try
{
userHdr.cardID = UInt32.Parse(userCardID.Text, System.Globalization.NumberStyles.HexNumber);
}
catch (Exception)
{
userHdr.cardID = 0;
}
try
{
userHdr.customID = (byte)Int32.Parse(cardCustomID.Text);
}
catch (Exception)
{
userHdr.customID = 0;
}
userHdr.version = BSSDK.BE_CARD_VERSION_1;
try
{
userHdr.accessGroupMask = UInt32.Parse(accessGroup.Text, System.Globalization.NumberStyles.HexNumber);
}
catch (Exception)
{
userHdr.accessGroupMask = 0xffffffff;
}
IntPtr userInfo = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(BSSDK.BSUserHdrEx)));
Marshal.StructureToPtr(userHdr, userInfo, true);
Cursor.Current = Cursors.WaitCursor;
result = BSSDK.BS_EnrollUserEx(m_Handle, userInfo, m_TemplateData);
Cursor.Current = Cursors.Default;
Marshal.FreeHGlobal(userInfo);
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot enroll the user", "Error");
return;
}
ReadUserInfo();
}
}
private void updateUser_Click(object sender, EventArgs e)
{
if (userList.SelectedItems.Count == 0)
{
MessageBox.Show("Please select a user first", "Error");
return;
}
uint ID = 0;
try
{
ID = UInt32.Parse(userList.SelectedItems[0].Text);
}
catch (Exception)
{
MessageBox.Show("Invalid ID", "Error");
return;
}
if (m_DeviceType == BSSDK.BS_DEVICE_BEPLUS || m_DeviceType == BSSDK.BS_DEVICE_BIOLITE)
{
IntPtr userInfo = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(BSSDK.BEUserHdr)));
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_GetUserBEPlus(m_Handle, ID, userInfo, m_TemplateData);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
Marshal.FreeHGlobal(userInfo);
MessageBox.Show("Cannot get the user", "Error");
return;
}
BSSDK.BEUserHdr userHdr = (BSSDK.BEUserHdr)Marshal.PtrToStructure(userInfo, typeof(BSSDK.BEUserHdr));
userHdr.adminLevel = (ushort)userLevel.SelectedIndex;
userHdr.securityLevel = (ushort)securityLevel.SelectedIndex;
userHdr.cardFlag = (byte)cardType.SelectedIndex;
userHdr.startTime = (int)((startDate.Value.Ticks - new DateTime(1970, 1, 1).Ticks) / 10000000);
userHdr.expiryTime = (int)((expiryDate.Value.Ticks - new DateTime(1970, 1, 1).Ticks) / 10000000);
userHdr.isDuress[0] = (duress1.Checked) ? (byte)1 : (byte)0;
userHdr.isDuress[1] = (duress2.Checked) ? (byte)1 : (byte)0;
userHdr.opMode = (ushort)authMode.SelectedIndex;
try
{
userHdr.cardID = UInt32.Parse(userCardID.Text, System.Globalization.NumberStyles.HexNumber);
}
catch (Exception)
{
userHdr.cardID = 0;
}
try
{
userHdr.cardCustomID = (byte)Int32.Parse(cardCustomID.Text);
}
catch (Exception)
{
userHdr.cardCustomID = 0;
}
try
{
userHdr.accessGroupMask = UInt32.Parse(accessGroup.Text, System.Globalization.NumberStyles.HexNumber);
}
catch (Exception)
{
userHdr.accessGroupMask = 0xffffffff;
}
Marshal.StructureToPtr(userHdr, userInfo, true);
Cursor.Current = Cursors.WaitCursor;
result = BSSDK.BS_EnrollUserBEPlus(m_Handle, userInfo, m_TemplateData);
Cursor.Current = Cursors.Default;
Marshal.FreeHGlobal(userInfo);
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot enroll the user", "Error");
}
}
else if (m_DeviceType == BSSDK.BS_DEVICE_BIOSTATION)
{
IntPtr userInfo = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(BSSDK.BSUserHdrEx)));
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_GetUserEx(m_Handle, ID, userInfo, m_TemplateData);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
Marshal.FreeHGlobal(userInfo);
MessageBox.Show("Cannot get the user", "Error");
return;
}
BSSDK.BSUserHdrEx userHdr = (BSSDK.BSUserHdrEx)Marshal.PtrToStructure(userInfo, typeof(BSSDK.BSUserHdrEx));
userHdr.adminLevel = (ushort)((userLevel.SelectedIndex == 1) ? BSSDK.BS_USER_ADMIN : BSSDK.BS_USER_NORMAL);
userHdr.securityLevel = (ushort)(securityLevel.SelectedIndex + BSSDK.BS_USER_SECURITY_DEFAULT);
userHdr.bypassCard = (byte)cardType.SelectedIndex;
userHdr.startDateTime = (uint)((startDate.Value.Ticks - new DateTime(1970, 1, 1).Ticks) / 10000000);
userHdr.expireDateTime = (uint)((expiryDate.Value.Ticks - new DateTime(1970, 1, 1).Ticks) / 10000000);
if (authMode.SelectedIndex == 0)
{
userHdr.authMode = 0;
}
else
{
userHdr.authMode = (ushort)(authMode.SelectedIndex + BSSDK.BS_AUTH_FINGER_ONLY - 1);
}
try
{
userHdr.cardID = UInt32.Parse(userCardID.Text, System.Globalization.NumberStyles.HexNumber);
}
catch (Exception)
{
userHdr.cardID = 0;
}
try
{
userHdr.customID = (byte)Int32.Parse(cardCustomID.Text);
}
catch (Exception)
{
userHdr.customID = 0;
}
try
{
userHdr.accessGroupMask = UInt32.Parse(accessGroup.Text, System.Globalization.NumberStyles.HexNumber);
}
catch (Exception)
{
userHdr.accessGroupMask = 0xffffffff;
}
Marshal.StructureToPtr(userHdr, userInfo, true);
Cursor.Current = Cursors.WaitCursor;
result = BSSDK.BS_EnrollUserEx(m_Handle, userInfo, m_TemplateData);
Cursor.Current = Cursors.Default;
Marshal.FreeHGlobal(userInfo);
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot enroll the user", "Error");
}
}
}
private void writeConfig_Click(object sender, EventArgs e)
{
if (m_DeviceType == BSSDK.BS_DEVICE_BEPLUS || m_DeviceType == BSSDK.BS_DEVICE_XPASS)
{
m_ConfigBEPlus.useDHCP = DHCP.Checked;
m_ConfigBEPlus.useServer = useServer.Checked;
m_ConfigBEPlus.synchTime = synchTime.Checked;
IPAddress addr = IPAddress.Parse(ipAddr.Text);
m_ConfigBEPlus.ipAddr = (uint)addr.Address;
addr = IPAddress.Parse(gateway.Text);
m_ConfigBEPlus.gateway = (uint)addr.Address;
addr = IPAddress.Parse(subnetMask.Text);
m_ConfigBEPlus.subnetMask = (uint)addr.Address;
addr = IPAddress.Parse(serverIP.Text);
m_ConfigBEPlus.serverIpAddr = (uint)addr.Address;
m_ConfigBEPlus.port = Int32.Parse(port.Text);
int configSize = Marshal.SizeOf(m_ConfigBEPlus);
IntPtr config = Marshal.AllocHGlobal(configSize);
Marshal.StructureToPtr(m_ConfigBEPlus, config, true);
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_WriteConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BEPLUS_CONFIG, configSize, config);
Marshal.FreeHGlobal(config);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot write the configuration", "Error");
}
}
else if (m_DeviceType == BSSDK.BS_DEVICE_BIOLITE)
{
m_ConfigBLN.useDHCP = DHCP.Checked;
m_ConfigBLN.useServer = useServer.Checked;
m_ConfigBLN.synchTime = synchTime.Checked;
IPAddress addr = IPAddress.Parse(ipAddr.Text);
m_ConfigBLN.ipAddr = (uint)addr.Address;
addr = IPAddress.Parse(gateway.Text);
m_ConfigBLN.gateway = (uint)addr.Address;
addr = IPAddress.Parse(subnetMask.Text);
m_ConfigBLN.subnetMask = (uint)addr.Address;
addr = IPAddress.Parse(serverIP.Text);
m_ConfigBLN.serverIpAddr = (uint)addr.Address;
m_ConfigBLN.port = Int32.Parse(port.Text);
int configSize = Marshal.SizeOf(m_ConfigBLN);
IntPtr config = Marshal.AllocHGlobal(configSize);
Marshal.StructureToPtr(m_ConfigBLN, config, true);
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_WriteConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BLN_CONFIG, configSize, config);
Marshal.FreeHGlobal(config);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot write the configuration", "Error");
}
}
else if (m_DeviceType == BSSDK.BS_DEVICE_BIOSTATION)
{
m_ConfigBST.useDHCP = DHCP.Checked;
m_ConfigBST.useServer = useServer.Checked;
m_ConfigBST.syncTimeWithServer = synchTime.Checked;
byte[] addr = Encoding.ASCII.GetBytes(ipAddr.Text);
Buffer.BlockCopy(addr, 0, m_ConfigBST.ipAddr, 0, addr.Length);
addr = Encoding.ASCII.GetBytes(gateway.Text);
Buffer.BlockCopy(addr, 0, m_ConfigBST.gateway, 0, addr.Length);
addr = Encoding.ASCII.GetBytes(subnetMask.Text);
Buffer.BlockCopy(addr, 0, m_ConfigBST.subnetMask, 0, addr.Length);
addr = Encoding.ASCII.GetBytes(serverIP.Text);
Buffer.BlockCopy(addr, 0, m_ConfigBST.serverIP, 0, addr.Length);
if (useServer.Checked)
{
m_ConfigBST.serverPort = UInt32.Parse(port.Text);
}
else
{
m_ConfigBST.port = UInt32.Parse(port.Text);
}
int configSize = Marshal.SizeOf(m_ConfigBST);
IntPtr config = Marshal.AllocHGlobal(configSize);
Marshal.StructureToPtr(m_ConfigBST, config, true);
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_WriteConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BS_CONFIG_TCPIP, configSize, config);
Marshal.FreeHGlobal(config);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot write the configuration", "Error");
}
}
else if (m_DeviceType == BSSDK.BS_DEVICE_DSTATION)
{
m_ConfigBST.useDHCP = DHCP.Checked;
m_ConfigBST.useServer = useServer.Checked;
m_ConfigBST.syncTimeWithServer = synchTime.Checked;
byte[] addr = Encoding.ASCII.GetBytes(ipAddr.Text);
Buffer.BlockCopy(addr, 0, m_ConfigBST.ipAddr, 0, addr.Length);
addr = Encoding.ASCII.GetBytes(gateway.Text);
Buffer.BlockCopy(addr, 0, m_ConfigBST.gateway, 0, addr.Length);
addr = Encoding.ASCII.GetBytes(subnetMask.Text);
Buffer.BlockCopy(addr, 0, m_ConfigBST.subnetMask, 0, addr.Length);
addr = Encoding.ASCII.GetBytes(serverIP.Text);
Buffer.BlockCopy(addr, 0, m_ConfigBST.serverIP, 0, addr.Length);
if (useServer.Checked)
{
m_ConfigBST.serverPort = UInt32.Parse(port.Text);
}
else
{
m_ConfigBST.port = UInt32.Parse(port.Text);
}
int configSize = Marshal.SizeOf(m_ConfigBST);
IntPtr config = Marshal.AllocHGlobal(configSize);
Marshal.StructureToPtr(m_ConfigBST, config, true);
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_WriteConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BS_CONFIG_TCPIP, configSize, config);
Marshal.FreeHGlobal(config);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot write the configuration", "Error");
}
}
else if (m_DeviceType == BSSDK.BS_DEVICE_XSTATION || m_DeviceType == BSSDK.BS_DEVICE_BIOSTATION2)
{
m_ConfigBST.useDHCP = DHCP.Checked;
m_ConfigBST.useServer = useServer.Checked;
m_ConfigBST.syncTimeWithServer = synchTime.Checked;
byte[] addr = Encoding.ASCII.GetBytes(ipAddr.Text);
Buffer.BlockCopy(addr, 0, m_ConfigBST.ipAddr, 0, addr.Length);
addr = Encoding.ASCII.GetBytes(gateway.Text);
Buffer.BlockCopy(addr, 0, m_ConfigBST.gateway, 0, addr.Length);
addr = Encoding.ASCII.GetBytes(subnetMask.Text);
Buffer.BlockCopy(addr, 0, m_ConfigBST.subnetMask, 0, addr.Length);
addr = Encoding.ASCII.GetBytes(serverIP.Text);
Buffer.BlockCopy(addr, 0, m_ConfigBST.serverIP, 0, addr.Length);
if (useServer.Checked)
{
m_ConfigBST.serverPort = UInt32.Parse(port.Text);
}
else
{
m_ConfigBST.port = UInt32.Parse(port.Text);
}
int configSize = Marshal.SizeOf(m_ConfigBST);
IntPtr config = Marshal.AllocHGlobal(configSize);
Marshal.StructureToPtr(m_ConfigBST, config, true);
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_WriteConfigUDP(m_Handle, m_DeviceAddr, m_DeviceID, BSSDK.BS_CONFIG_TCPIP, configSize, config);
Marshal.FreeHGlobal(config);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot write the configuration", "Error");
}
}
}
private bool ReadUserInfo()
{
int numUser = 0;
int numTemplate = 0;
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_GetUserDBInfo(m_Handle, ref numUser, ref numTemplate);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
MessageBox.Show("Cannot get user DB info", "Error");
return(false);
}
numOfUser.Text = numUser.ToString();
numOfTemplate.Text = numTemplate.ToString();
m_NumOfUser = numUser;
if (m_DeviceType == BSSDK.BS_DEVICE_BEPLUS || m_DeviceType == BSSDK.BS_DEVICE_BIOLITE)
{
BSSDK.BEUserHdr[] userHdr = new BSSDK.BEUserHdr[m_NumOfUser];
IntPtr userInfo = Marshal.AllocHGlobal(m_NumOfUser * Marshal.SizeOf(typeof(BSSDK.BEUserHdr)));
Cursor.Current = Cursors.WaitCursor;
result = BSSDK.BS_GetAllUserInfoBEPlus(m_Handle, userInfo, ref m_NumOfUser);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS && result != BSSDK.BS_ERR_NOT_FOUND)
{
Marshal.FreeHGlobal(userInfo);
MessageBox.Show("Cannot get user header info", "Error");
return(false);
}
userList.Items.Clear();
for (int i = 0; i < m_NumOfUser; i++)
{
userHdr[i] = (BSSDK.BEUserHdr)Marshal.PtrToStructure(new IntPtr(userInfo.ToInt32() + i * Marshal.SizeOf(typeof(BSSDK.BEUserHdr))), typeof(BSSDK.BEUserHdr));
ListViewItem userItem = userList.Items.Add(userHdr[i].userID.ToString());
userItem.SubItems.Add(userHdr[i].numOfFinger.ToString());
userItem.SubItems.Add(userHdr[i].cardID.ToString("X"));
}
Marshal.FreeHGlobal(userInfo);
}
else if (m_DeviceType == BSSDK.BS_DEVICE_BIOSTATION)
{
BSSDK.BSUserHdrEx[] userHdr = new BSSDK.BSUserHdrEx[m_NumOfUser];
IntPtr userInfo = Marshal.AllocHGlobal(m_NumOfUser * Marshal.SizeOf(typeof(BSSDK.BSUserHdrEx)));
Cursor.Current = Cursors.WaitCursor;
result = BSSDK.BS_GetAllUserInfoEx(m_Handle, userInfo, ref m_NumOfUser);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS && result != BSSDK.BS_ERR_NOT_FOUND)
{
Marshal.FreeHGlobal(userInfo);
MessageBox.Show("Cannot get user header info", "Error");
return(false);
}
userList.Items.Clear();
for (int i = 0; i < m_NumOfUser; i++)
{
userHdr[i] = (BSSDK.BSUserHdrEx)Marshal.PtrToStructure(new IntPtr(userInfo.ToInt32() + i * Marshal.SizeOf(typeof(BSSDK.BSUserHdrEx))), typeof(BSSDK.BSUserHdrEx));
ListViewItem userItem = userList.Items.Add(userHdr[i].ID.ToString());
userItem.SubItems.Add(userHdr[i].numOfFinger.ToString());
userItem.SubItems.Add(userHdr[i].cardID.ToString("X"));
}
Marshal.FreeHGlobal(userInfo);
}
if (m_NumOfUser > 0)
{
try
{
uint ID = UInt32.Parse(userList.Items[0].Text);
ReadUser(ID);
}
catch (Exception)
{
}
}
return(true);
}
private void ReadUser(uint ID)
{
if (m_DeviceType == BSSDK.BS_DEVICE_BEPLUS || m_DeviceType == BSSDK.BS_DEVICE_BIOLITE)
{
IntPtr userInfo = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(BSSDK.BEUserHdr)));
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_GetUserBEPlus(m_Handle, ID, userInfo, m_TemplateData);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
Marshal.FreeHGlobal(userInfo);
MessageBox.Show("Cannot get user info", "Error");
return;
}
BSSDK.BEUserHdr userHdr = (BSSDK.BEUserHdr)Marshal.PtrToStructure(userInfo, typeof(BSSDK.BEUserHdr));
Marshal.FreeHGlobal(userInfo);
userID.Text = userHdr.userID.ToString();
userCardID.Text = userHdr.cardID.ToString("X");
cardCustomID.Text = userHdr.cardCustomID.ToString();
userLevel.SelectedIndex = userHdr.adminLevel;
securityLevel.SelectedIndex = userHdr.securityLevel;
cardType.SelectedIndex = userHdr.cardFlag;
name.Text = "";
accessGroup.Text = userHdr.accessGroupMask.ToString("X");
if (userHdr.opMode >= BSSDK.BS_AUTH_FINGER_ONLY && userHdr.opMode <= BSSDK.BS_AUTH_CARD_ONLY)
{
authMode.SelectedIndex = userHdr.opMode - BSSDK.BS_AUTH_FINGER_ONLY + 1;
}
else
{
authMode.SelectedIndex = 0;
}
startDate.Value = new DateTime(1970, 1, 1).AddSeconds(userHdr.startTime);
expiryDate.Value = new DateTime(1970, 1, 1).AddSeconds(userHdr.expiryTime);
if (userHdr.numOfFinger > 0)
{
finger1.Checked = true;
duress1.Checked = (userHdr.isDuress[0] == 1);
checksum1.Text = userHdr.fingerChecksum[0].ToString();
}
else
{
finger1.Checked = false;
duress1.Checked = false;
checksum1.Text = "";
}
if (userHdr.numOfFinger > 1)
{
finger2.Checked = true;
duress2.Checked = (userHdr.isDuress[1] == 1);
checksum2.Text = userHdr.fingerChecksum[1].ToString();
}
else
{
finger2.Checked = false;
duress2.Checked = false;
checksum2.Text = "";
}
}
else if (m_DeviceType == BSSDK.BS_DEVICE_BIOSTATION)
{
IntPtr userInfo = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(BSSDK.BSUserHdrEx)));
Cursor.Current = Cursors.WaitCursor;
int result = BSSDK.BS_GetUserEx(m_Handle, ID, userInfo, m_TemplateData);
Cursor.Current = Cursors.Default;
if (result != BSSDK.BS_SUCCESS)
{
Marshal.FreeHGlobal(userInfo);
MessageBox.Show("Cannot get user info", "Error");
return;
}
BSSDK.BSUserHdrEx userHdr = (BSSDK.BSUserHdrEx)Marshal.PtrToStructure(userInfo, typeof(BSSDK.BSUserHdrEx));
Marshal.FreeHGlobal(userInfo);
userID.Text = userHdr.ID.ToString();
userCardID.Text = userHdr.cardID.ToString("X");
cardCustomID.Text = userHdr.customID.ToString();
userLevel.SelectedIndex = (userHdr.adminLevel == BSSDK.BS_USER_ADMIN) ? 1 : 0;
securityLevel.SelectedIndex = (userHdr.securityLevel >= BSSDK.BS_USER_SECURITY_DEFAULT) ? userHdr.securityLevel - BSSDK.BS_USER_SECURITY_DEFAULT : 0;
cardType.SelectedIndex = userHdr.bypassCard;
name.Text = Encoding.ASCII.GetString(userHdr.name);
accessGroup.Text = userHdr.accessGroupMask.ToString("X");
if (userHdr.authMode >= BSSDK.BS_AUTH_FINGER_ONLY && userHdr.authMode <= BSSDK.BS_AUTH_CARD_ONLY)
{
authMode.SelectedIndex = userHdr.authMode - BSSDK.BS_AUTH_FINGER_ONLY + 1;
}
else
{
authMode.SelectedIndex = 0;
}
startDate.Value = new DateTime(1970, 1, 1).AddSeconds(userHdr.startDateTime);
expiryDate.Value = new DateTime(1970, 1, 1).AddSeconds(userHdr.expireDateTime);
if (userHdr.numOfFinger > 0)
{
finger1.Checked = true;
duress1.Checked = (userHdr.duressMask & 0x01) == 0x01;
checksum1.Text = userHdr.checksum[0].ToString();
}
else
{
finger1.Checked = false;
duress1.Checked = false;
checksum1.Text = "";
}
if (userHdr.numOfFinger > 1)
{
finger2.Checked = true;
duress2.Checked = (userHdr.duressMask & 0x02) == 0x02;
checksum2.Text = userHdr.checksum[1].ToString();
}
else
{
finger2.Checked = false;
duress2.Checked = false;
checksum2.Text = "";
}
}
}
