Beispiel #1
0
        private Csta.ConnectionID_t[] GetCurrentConnections(Csta.DeviceID_t device)
        {
            if (!this.configured)
            {
                MessageBox.Show("Application is not configured");
                this.mainTabs.SelectTab(configTab);
                return null;
            }
            if (!streamCheckbox.Checked || deviceTextBox.Text.Length == 0 || deviceTextBox.Text.Length > 5 || !streamCheckbox.Checked) { return null; }
            Csta.DeviceID_t currentDevice = device;
            Acs.InvokeID_t invokeId = new Acs.InvokeID_t();
            Acs.RetCode_t retCode = Csta.cstaSnapshotDeviceReq(this.acsHandle,
                                                 invokeId,
                                                 ref currentDevice,
                                                 privData);
            if (retCode._value < 0)
            {
                MessageBox.Show("cstaSnapshotDeviceReq error: " + retCode);
                return null;
            }
            var evtBuf = new Csta.EventBuffer_t();
            this.privData.length = Att.ATT_MAX_PRIVATE_DATA;
            ushort eventBufSize = Csta.CSTA_MAX_HEAP;
            ushort numEvents;
            retCode = Acs.acsGetEventBlock(this.acsHandle,
                                          evtBuf,
                                          ref eventBufSize,
                                          privData,
                                          out numEvents);

            if (retCode._value != Acs.ACSPOSITIVE_ACK)
            {
                MessageBox.Show("acsGetEventBlock error: " + retCode);
                return null;
            }
            if (evtBuf.evt.eventHeader.eventClass.eventClass != Csta.CSTACONFIRMATION || evtBuf.evt.eventHeader.eventType.eventType != Csta.CSTA_SNAPSHOT_DEVICE_CONF)
            {
                if (evtBuf.evt.eventHeader.eventClass.eventClass == Csta.CSTACONFIRMATION && evtBuf.evt.eventHeader.eventType.eventType == Csta.CSTA_UNIVERSAL_FAILURE_CONF)
                {
                    MessageBox.Show("Snapshot device failed. Error: " + evtBuf.evt.cstaConfirmation.universalFailure.error);
                }
                return null;
            }
            int callCount = evtBuf.evt.cstaConfirmation.snapshotDevice.snapshotData.count;
            Csta.ConnectionID_t[] conns = new Csta.ConnectionID_t[callCount];
            for (int i = 0; i < callCount; i++)
            {
                var snapDeviceInfoArray = (Csta.CSTASnapshotDeviceResponseInfo_t[])evtBuf.auxData["snapDeviceInfo"];
                conns[i] = snapDeviceInfoArray[i].callIdentifier;
            }
            return conns;
        }
Beispiel #2
0
        private void attSelectiveListeningRetrieveButton_Click(object sender, EventArgs e)
        {
            if (!streamCheckbox.Checked || deviceTextBox.Text.Length == 0 || deviceTextBox.Text.Length > 5 || !streamCheckbox.Checked) { return; }

            Csta.DeviceID_t currentDevice = deviceTextBox.Text;
            Acs.InvokeID_t invokeId = new Acs.InvokeID_t();
            Acs.RetCode_t retCode = Csta.cstaSnapshotDeviceReq(this.acsHandle,
                                                 invokeId,
                                                 ref currentDevice,
                                                 this.privData);
            if (retCode._value < 0)
            {
                MessageBox.Show("cstaSnapshotDeviceReq error: " + retCode);
                return;
            }
            Csta.EventBuffer_t evtBuf = new Csta.EventBuffer_t();
            this.privData.length = Att.ATT_MAX_PRIVATE_DATA;
            ushort eventBufSize = Csta.CSTA_MAX_HEAP;
            ushort numEvt;
            retCode = Acs.acsGetEventBlock(this.acsHandle,
                                          evtBuf,
                                          ref eventBufSize,
                                          privData,
                                          out numEvt);
            if (retCode._value < 0)
            {
                MessageBox.Show("acsGetEventBlock error: " + retCode);
                return;
            }
            if (evtBuf.evt.eventHeader.eventClass.eventClass != Csta.CSTACONFIRMATION || evtBuf.evt.eventHeader.eventType.eventType != Csta.CSTA_SNAPSHOT_DEVICE_CONF)
            {
                if (evtBuf.evt.eventHeader.eventClass.eventClass == Csta.CSTACONFIRMATION && evtBuf.evt.eventHeader.eventType.eventType == Csta.CSTA_UNIVERSAL_FAILURE_CONF)
                {
                    MessageBox.Show("Snapshot device failed. Error: " + evtBuf.evt.cstaConfirmation.universalFailure.error);
                }
                return;
            }
            int callCountForSnapshotDevice = evtBuf.evt.cstaConfirmation.snapshotDevice.snapshotData.count;
            if (callCountForSnapshotDevice < 1)
            {
                MessageBox.Show("No active calls");
                return;
            }
            var snapDeviceInfoArray = (Csta.CSTASnapshotDeviceResponseInfo_t[])evtBuf.auxData["snapDeviceInfo"];
            var firstConn = snapDeviceInfoArray[0].callIdentifier;
            Csta.EventBuffer_t snapCallEvt = snapshotCall(firstConn);
            int callCountForSnapshotCall = snapCallEvt.evt.cstaConfirmation.snapshotCall.snapshotData.count;
            var snapCallInfoArray = (Csta.CSTASnapshotCallResponseInfo_t[])snapCallEvt.auxData["snapCallInfo"];

            var snapCallConnsArray = new Csta.ConnectionID_t[snapCallInfoArray.Length];
            for (int i = 0; i < snapCallInfoArray.Length; i++)
            {
                snapCallConnsArray[i] = snapCallInfoArray[i].callIdentifier;
            }

            var selectiveListeningRetruevePopup = new attSelectiveListeningRetrievePopupForm(snapCallConnsArray);
            selectiveListeningRetruevePopup._parent = this;
            selectiveListeningRetruevePopup.ShowDialog();
        }
Beispiel #3
0
        public static Att.ATTUCID_t[] GetUcid(Csta.DeviceID_t device)
        {
            Acs.ACSHandle_t acsHandle;
            Acs.InvokeID_t invokeId;

            // Set PrivateData request
            var privData = new Acs.PrivateData_t();
            privData.vendor = "VERSION";
            privData.data = new byte[1024];
            privData.data[0] = Acs.PRIVATE_DATA_ENCODING;

            // Get supportedVersion string
            string requestedVersion = "3-7"; // Private Data version request
            System.Text.StringBuilder supportedVersion = new System.Text.StringBuilder();
            Acs.RetCode_t attrc = Att.attMakeVersionString(requestedVersion, supportedVersion);
            //Console.WriteLine("attrc = " + attrc + "; supportedVersion = " + supportedVersion);

            for (int i = 0; i < supportedVersion.Length; i++)
            {
                privData.data[i + 1] = (byte)supportedVersion[i];
            }
            privData.length = Att.ATT_MAX_PRIVATE_DATA;

            Acs.RetCode_t retCode = OpenStream(out acsHandle, out invokeId, ref privData);
            //Console.WriteLine("acsOpenStream retCode = " + retCode + ", Handle = " + acsHandle.ToString());

            retCode = Csta.cstaSnapshotDeviceReq(acsHandle,
                                     invokeId,
                                     ref device,
                                     ref privData);

            privData.length = Att.ATT_MAX_PRIVATE_DATA;
            Csta.CSTAEvent_t evt = new Csta.CSTAEvent_t();
            ushort eventBufSize = Csta.CSTA_MAX_HEAP;
            ushort numEvents = 0;
            retCode = Acs.acsGetEventBlock(acsHandle,
                                          out evt,
                                          ref eventBufSize,
                                          ref privData,
                                          out numEvents);

            int callCount = evt.cstaConfirmation.snapshotDevice.snapshotData.count;
            Csta.ConnectionID_t[] connections = new Csta.ConnectionID_t[callCount];
            for (int i = 0; i < evt.cstaConfirmation.snapshotDevice.snapshotData.count; i++)
            {
                connections[i] = evt.cstaConfirmation.snapshotDevice.snapshotData.info[i].callIdentifier;
            }

            if (callCount > 0)
            {
                //Console.WriteLine(evt.cstaConfirmation.snapshotDevice.snapshotData);
                //Console.WriteLine(evt.cstaConfirmation.snapshotDevice.snapshotData.info[1].localCallState);
                Att.ATTUCID_t[] ucids = new Att.ATTUCID_t[callCount];
                for (int i = 0; i < callCount; i++)
                {
                    //Csta.ConnectionID_t connection = evt.cstaConfirmation.snapshotDevice.snapshotData.info[i].callIdentifier;

                    retCode = Att.attQueryUCID(ref privData, ref connections[i]);
                    //Console.WriteLine("attQueryUCID retCode = " + retCode);
                    //Console.WriteLine("privData.Length = " + privData.length);

                    retCode = Csta.cstaEscapeService(acsHandle, invokeId, ref privData);
                    //Console.WriteLine("cstaEscapeService retCode = " + retCode);
                    //Console.WriteLine("privData.Length = " + privData.length);
                    // Set private data length (we'll have to call GetEventBlock otherwise)
                    privData.length = Att.ATT_MAX_PRIVATE_DATA;
                    retCode = Acs.acsGetEventBlock(acsHandle,
                                                 out evt,
                                                 ref eventBufSize,
                                                 ref privData,
                                                 out numEvents);

                    //Console.WriteLine("acsGetEventBlock retCode = " + retCode + " Buffer size = " + eventBufSize + ", numEvents = " + numEvents);
                    //Console.WriteLine("eventClass = " + evt.eventHeader.eventClass);
                    //Console.WriteLine("eventType = " + evt.eventHeader.eventType);
                    //Console.WriteLine("privData.Length = " + privData.length);

                    // Decode ATTPrivateData
                    Att.ATTEvent_t attevt;
                    retCode = Att.attPrivateData(ref privData, out attevt);
                    ucids[i] = attevt.queryUCID.ucid;
                    //Console.WriteLine("attPrivateData retCode = " + retCode);
                    //Console.WriteLine("privData.Length = " + privData.length);
                    //Console.WriteLine("ATTeventType  = " + attevt.eventType);
                    //Console.WriteLine("ucid #{0} = {1}", i + 1, attevt.queryUCID.ucid);
                }
                Acs.acsAbortStream(acsHandle, out privData);
                return ucids;
            }
            else
            {
                Console.WriteLine("No active calls");
                Acs.acsAbortStream(acsHandle, out privData);
                return new Att.ATTUCID_t[0];
            }
        }