C#

        private void cmdPrintReport_Click(object sender, EventArgs e)
        {

            CrystalReport_Quotation1.SetDatabaseLogon("DB_USER_AFDR", "1237894560");
            crvQuotation.ReportSource = CrystalReport_Quotation1;
            crvQuotation.Refresh();
            
}

using my.data;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Threading;

namespace CnaFirmware
{

    public class DbUpdateFromField
    {
        Dictionary<string, CNA> cnas;
        ConcurrentQueue<string> ConsoleQueue;
        EventWaitHandle UpdateComplete;
        ClsUdpDispatcher UdpDispatcher;
        List<string> updates;

        // this class starts a thread that downloads config data from all cnas, then updates the cna_firmware table.
        class CNA
        {
            public string ip;
            public string firmware;
            public int cktid;
            public bool updated;
            public bool error;

            public CNA(string i, string f, int c)
            {
                this.ip = i;
                this.firmware = f;
                this.cktid = c;
                this.updated = false;
                this.error = false;
            }
        }

        public DbUpdateFromField(ClsUdpDispatcher disp, ConcurrentQueue<string> q, EventWaitHandle op_done)
        {
            UdpDispatcher = disp;
            ConsoleQueue = q;
            UpdateComplete = op_done;
            Log("start");
            updates = new List<string>();
            cnas = new Dictionary<string, CNA>();
            new Thread(() => Start()).Start();
        }

        void Start()
        {
            GetIpList();
            GetCnaData();
        }
        void Log(string s)
        {
            ConsoleQueue.Enqueue("DbUpdate: " + s);
        }

        void GetCnaData()
        {
            SqlConnection DB;
            foreach (var v in cnas)
            {
                // get data from each cna, in sequence (not concurrent)
                new Thread(() => GetCnaInfo(v.Value)).Start();
            }
            // loop through all the cnas until either error or complete flag is set
            bool done;
            do
            {
                Thread.Sleep(50);
                done = true;
                foreach (var v in cnas)
                {
                    if (!v.Value.updated && !v.Value.error) done = false;
                }
            } while (!done);

            // all field cnas have responded or timed out. now update the DB
            if (updates.Count > 0)
            {
                Log(string.Format("Sending {0} updates to database...", updates.Count));

                using (DB = new SqlConnection(Globals.ConnectionString))
                {
                    try
                    {
                        DB.Open();
                    }
                    catch (Exception ex)
                    {
                        Log(ex.Message);
                        return;
                    }

                    try
                    {
                        using (SqlCommand sql = new SqlCommand())
                        {
                            sql.Connection = DB;
                            foreach (string query in updates)
                            {
                                sql.CommandText = query;
                                sql.ExecuteNonQuery();

                                // not sure if this is necessary
                                Thread.Sleep(10);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Log(ex.Message);
                        return;
                    }
                }
            }
            else
            {
                Log("No updates");
            }

            Log("Operation complete");
            UpdateComplete.Set();
        }
        /*
 typedef struct
{
0            unsigned char  version;     // 1 or 2
1            unsigned char firmware[3];  // v2 only
2            unsigned char flags;        // v2 only
3            unsigned short not_used;    //
4            unsigned short label;
5            unsigned short len;      //<-- This is the length of the payload data (config data in our example).
}CCI_HDR_T;

 * header is followed by configuration data: all structs are the same first four bytes
 * 
 * typedef struct
    {
6                unsigned short cnaID;         // HEX <-- Hard coded to 0x1003
7                unsigned short version;       // HEX
    }
 * 
 * 00 11 11 11 22 33 33 44 44 55 55 66 66 77 77
 */
        void SendGetConfig(string ip, ConcurrentQueue<UdpMessage> C)
        {
            byte[] msg = new byte[11];
            msg[0] = 1;
            msg[7] = 5;
            msg[8] = 0x42; // rx = 0x43
            UdpDispatcher.Send(new UdpMessage(ip, 20367, msg, 11), C);
        }
        void GetCnaInfo(CNA cna)
        {
            int WaitTicks;
            ConcurrentQueue<UdpMessage> CnaRxQ = new ConcurrentQueue<UdpMessage>();
            int tries = 0;
            while (++tries < 4)
            {
                WaitTicks = 0;
                //if (tries > 1) ConsoleQueue.Enqueue(string.Format("{0}: retry get-config",IpAddress));
                SendGetConfig(cna.ip, CnaRxQ);
                while (++WaitTicks < 100) // 10 seconds
                {
                    if (CnaRxQ.TryDequeue(out UdpMessage msg))
                    {
                        ushort label = (ushort)((msg.data[7] << 8) + (ushort)msg.data[8]);
                        if (label == 0x0543)
                        {
                            // this is a CONFIG_REPLY:
                            if (msg.data[0] > 1)
                            {
                                string firmware = string.Format("{0}.{1}.{2}", msg.data[1], msg.data[2], msg.data[3]);
                                //ushort platform = (ushort)((msg.data[11] << 8) + (ushort)msg.data[12]);  // HEX!
                                //ushort version = (ushort)((msg.data[13] << 8) + (ushort)msg.data[14]);
                                //Platform = string.Format("{0:X4}.{1}", platform, version);
                                cna.updated = true;
                                // don't update db unless they are different:
                                if (cna.firmware == firmware)
                                {
                                    Log(string.Format("Skipping {0}: firmware is current", cna.ip));
                                }
                                else
                                {
                                    Log("Updating " + cna.ip);
                                    QueryBuilder qb = new QueryBuilder("update cna_firmware set firmware_rev = ");
                                    qb.AddString(firmware, QBOptions.NONE);
                                    qb.Query += " where ip_address = ";
                                    qb.AddString(cna.ip, QBOptions.NONE);
                                    updates.Add(qb.Query);
                                }
                                return;
                            }
                            else
                            {
                                // got unexpected data
                                Log(string.Format("Skipping {0}: unexpected data received", cna.ip));
                                return;
                            }
                        }
                        else
                        {
                            // got unexpected data
                            Log(string.Format("Skipping {0}: unexpected data received", cna.ip));
                            return;
                        }
                    }
                    Thread.Sleep(100);
                }
            }
            Log("Unable to fetch config data from " + cna.ip);
            cna.error = true;
        }

        void GetIpList()
        {
            SqlConnection DB;
            string query;
            using (DB = new SqlConnection(Globals.ConnectionString))
            {
                try
                {
                    DB.Open();
                }
                catch (Exception)
                {
                    UpdateComplete.Set();
                    return;
                }
                query = "select ip_address, n_cktid, firmware_rev from cna_firmware order by ip_address";
                try
                {
                    using (SqlCommand sql = new SqlCommand(query, DB))
                    {
                        using (SqlDataReader dr = sql.ExecuteReader())
                        {
                            if (dr.HasRows)
                            {
                                while (dr.Read())
                                {
                                    int ckt = Sql.Read<int>(dr, "n_cktid");
                                    string ip = Sql.Read<string>(dr, "ip_address");
                                    string fw = Sql.Read<string>(dr, "firmware_rev");
                                    if (cnas.ContainsKey(ip)) continue;
                                    cnas.Add(ip, new CNA(ip, fw, ckt));
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    Log(ex.Message);
                }
            }
        }
    }
}