Exemplo n.º 1
0
 /// <summary>
 /// Request trap event arguments
 /// </summary>
 /// <param name="tvReqInfo"></param>
 /// <param name="httpReqInfo"></param>
 /// <param name="httpRespInfo"></param>
 /// <param name="reqLock"></param>
 public RequestTrapEventEventArgs(TVRequestInfo tvReqInfo, HttpRequestInfo httpReqInfo, HttpResponseInfo httpRespInfo, ManualResetEvent reqLock)
 {
     _tvReqInfo    = tvReqInfo;
     _reqLock      = reqLock;
     _httpReqInfo  = httpReqInfo;
     _httpRespInfo = httpRespInfo;
 }
Exemplo n.º 2
0
        /// <summary>
        /// Replaces the specified set of matches with the replacement string
        /// </summary>
        /// <param name="matchList"></param>
        /// <param name="replacement"></param>
        public void Replace(IList <LineMatch> matchList, string replacement)
        {
            int count = matchList.Count;

            for (int i = count - 1; i > -1; i--)
            {
                LineMatch match = matchList[i];
                if (match.Context == SearchContext.Request)
                {
                    byte[] reqBytes = LoadRequestData(match.RequestId);
                    reqBytes = ReplaceInComponent(reqBytes, match, replacement);
                    SaveRequest(match.RequestId, reqBytes);
                    //update request line
                    TVRequestInfo reqInfo = GetRequestInfo(match.RequestId);
                    if (String.Compare(match.Line, reqInfo.RequestLine) == 0)
                    {
                        HttpRequestInfo httpReqInfo = new HttpRequestInfo(reqBytes);
                        reqInfo.RequestLine = httpReqInfo.RequestLine;
                    }
                }
                else if (match.Context == SearchContext.Response)
                {
                    byte[] respBytes = LoadResponseData(match.RequestId);
                    respBytes = ReplaceInComponent(respBytes, match, replacement);
                    SaveResponse(match.RequestId, respBytes);
                }
            }

            if (ReplaceEvent != null)
            {
                ReplaceEvent.Invoke(new ReplaceEventArgs(matchList, replacement));
            }
        }
Exemplo n.º 3
0
        /// <summary>
        /// Adds a new request info row to the list
        /// </summary>
        /// <param name="header"></param>
        /// <returns>The index of the new entry</returns>
        public int AddRequestInfo(TVRequestInfo header)
        {
            int result = -1;

            try
            {
                lock (_lockData)                 //critical section begins
                {
                    if (header.Id == -1)
                    {
                        if (_firstIndex == -1)
                        {
                            _firstIndex = 0;
                            _lastIndex  = 0;
                        }
                        else
                        {
                            _lastIndex++;
                        }

                        //save the index in the request header
                        header.Id = _lastIndex;
                    }
                    else
                    {
                        if (_firstIndex == -1)
                        {
                            _firstIndex = header.Id;
                        }
                        _lastIndex = header.Id;
                    }
                    _requestInfos.Add(_lastIndex, header);
                    //new request header was added to the list
                    //this means that we have at least the request line
                    //call the RequestAdded event

                    result = _lastIndex;
                }                 //end critical section

                //now that the data was added invoke the event
                if (RequestEntryAdded != null)
                {
                    TVDataAccessorDataArgs e = new TVDataAccessorDataArgs(_lastIndex, header);
                    RequestEntryAdded.Invoke(e);
                }
            }
            catch (Exception ex)
            {
                SdkSettings.Instance.Logger.Log(TraceLevel.Error, "An error occured while adding a request info: {0}", ex.ToString());
            }

            return(result);
        }
Exemplo n.º 4
0
        /// <summary>
        /// Replaces the index at header.id with the passed object and signals that the request info was updated to all listeners
        /// </summary>
        /// <param name="header"></param>
        /// <returns>The index of the new entry</returns>
        public void UpdateRequestInfo(TVRequestInfo header)
        {
            lock (_lockData)
            {
                _requestInfos[header.Id] = header;
            }

            if (RequestEntryUpdated != null)
            {
                TVDataAccessorDataArgs e = new TVDataAccessorDataArgs(header.Id, header);
                RequestEntryUpdated.Invoke(e);
            }
        }
Exemplo n.º 5
0
        /// <summary>
        /// Appends the specified request with the associated raw response to the current traffic file and returns the request id
        /// </summary>
        /// <param name="request"></param>
        /// <param name="response"></param>
        /// <param name="isHttps"></param>
        /// <returns></returns>
        public int AddRequestResponse(byte[] request, byte[] response, bool isHttps)
        {
            TVRequestInfo tvReqInfo = new TVRequestInfo();

            tvReqInfo.RequestLine    = HttpRequestInfo.GetRequestLine(request);
            tvReqInfo.Description    = "N/A";
            tvReqInfo.RequestTime    = DateTime.Now;
            tvReqInfo.ResponseTime   = DateTime.Now;
            tvReqInfo.ThreadId       = Utils.GetCurrentWin32ThreadId().ToString();
            tvReqInfo.IsHttps        = isHttps;
            tvReqInfo.ResponseStatus = HttpResponseInfo.GetResponseStatus(response);

            AddRequestInfo(tvReqInfo);

            SaveRequestResponse(tvReqInfo.Id, request, response);

            return(tvReqInfo.Id);
        }
Exemplo n.º 6
0
        private void Load()
        {
            SetState(AccessorState.Loading);
            //Open the decompressed files

            //load index
            byte[]        bytes;
            string        line;
            int           currentIndex = -1, count = 0;
            TVRequestInfo currentRequestInfo;

            _requestInfos   = new SortedDictionary <int, TVRequestInfo>();
            _rawTrafficFile = File.Open(_tempFileFolder + "\\" + RAW_TRAFFIC_FILE_NAME, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite);

            XmlDocument customDataFile = new XmlDocument();

            customDataFile.XmlResolver = null;
            if (File.Exists(_tempFileFolder + "\\" + CUSTOM_DATA_FILE_NAME))
            {
                customDataFile.Load(_tempFileFolder + "\\" + CUSTOM_DATA_FILE_NAME);
            }

            Profile = new ParsingOptions();

            //Load the parsing options that were used to create this file
            if (File.Exists(_tempFileFolder + "\\" + OPTIONS_FILE_NAME))
            {
                Profile.Load(_tempFileFolder + "\\" + OPTIONS_FILE_NAME);
            }


            _firstIndex = -1;
            FileStream indexFile = File.Open(_tempFileFolder + "\\" + INDEX_FILE_NAME, FileMode.OpenOrCreate, FileAccess.ReadWrite);

            while ((bytes = Utils.ReadLine(indexFile, ESTIMATED_LINE_SIZE)) != null)
            {
                try
                {
                    line = Utils.ByteToString(bytes);

                    currentRequestInfo = new TVRequestInfo();

                    currentRequestInfo.ReadValues(line);

                    currentIndex = currentRequestInfo.Id;

                    AddRequestInfo(currentRequestInfo);

                    //load the data for the first requests in the buffer
                    if (!RequestDataCache.Instance.MaxSizeReached)
                    {
                        this.LoadRequestData(currentIndex);
                        this.LoadResponseData(currentIndex);
                    }

                    //load custom fields
                    XmlNodeList customFields = customDataFile.SelectNodes(
                        String.Format("/Requests/Request[@id='{0}']/Field", currentIndex));
                    if (customFields.Count > 0)
                    {
                        currentRequestInfo.CustomFields = new Dictionary <string, string>();
                        foreach (XmlNode node in customFields)
                        {
                            currentRequestInfo.CustomFields.Add(node.Attributes["name"].Value, node.InnerText);
                        }
                    }


                    count++;
                }
                catch (Exception ex)
                {
                    SdkSettings.Instance.Logger.Log(TraceLevel.Error, "Error loading request from index: {0}", ex.Message);
                }
            }
            //set the position of the rawdatafile to the end
            _rawTrafficFile.Position = _rawTrafficFile.Length;

            //close the other files
            indexFile.Close();

            //set the keep on close flag to false
            _keepOnClose = false;
            SetState(AccessorState.Idle);
        }
Exemplo n.º 7
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="requestId"></param>
 /// <param name="header"></param>
 public TVDataAccessorDataArgs(int requestId, TVRequestInfo header)
 {
     _requestId = requestId;
     _header    = header;
 }
Exemplo n.º 8
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="tvReqInfo"></param>
 /// <param name="reqLock"></param>
 public RequestTrapEventEventArgs(TVRequestInfo tvReqInfo, ManualResetEvent reqLock) : this(tvReqInfo, null, null, reqLock)
 {
 }
Exemplo n.º 9
0
 /// <summary>
 /// COnstructor
 /// </summary>
 /// <param name="tvReqInfo"></param>
 /// <param name="httpRespInfo"></param>
 /// <param name="reqLock"></param>
 public RequestTrapEventEventArgs(TVRequestInfo tvReqInfo, HttpResponseInfo httpRespInfo, ManualResetEvent reqLock) : this(tvReqInfo, null, httpRespInfo, reqLock)
 {
 }
Exemplo n.º 10
0
        /// <summary>
        /// Saves response bytes to disk and caches it if tail is on
        /// </summary>
        /// <param name="requestId"></param>
        /// <param name="data">Request data object storing the response</param>
        public void SaveResponse(int requestId, RequestResponseBytes data)
        {
            if (data == null || data.RawResponse == null)
            {
                return;
            }

            bool          isResponseChanged = false;
            TVRequestInfo reqInfo           = null;

            try
            {
                lock (_lockData)                 //critical section begins
                {
                    if (_requestInfos.ContainsKey(requestId))
                    {
                        //save to memory buffer only if tail is on
                        //this is done to use minimum memory footprint since on
                        //normal load the user is viewing the requests
                        //at the beginning of the file
                        reqInfo = _requestInfos[requestId];
                        //save to disk
                        reqInfo.ResponseStartPosition = WritePosition;

                        string respStatus = null;

                        if (_tailInProgress || RequestDataCache.Instance.GetEntry(_objectId ^ requestId) != null || reqInfo.IsEncrypted)
                        {
                            byte[] rawResponse = data.RawResponse;
                            respStatus = HttpResponseInfo.GetResponseStatus(rawResponse);
                            //this takes memory but at the same time insures that the user can see the data fast during tail

                            if (reqInfo.IsEncrypted)
                            {
                                rawResponse = Encryptor.Encrypt(rawResponse);
                            }

                            BufferSaveResponse(requestId, rawResponse);
                            DataWrite(rawResponse, 0, rawResponse.Length);
                            reqInfo.ResponseLength = rawResponse.Length;
                        }
                        else
                        {
                            byte[] chunk;
                            //this saves memory and writes the chunks of data directly to disk
                            data.ResetResponseChunkPosition();
                            while ((chunk = data.ReadResponseChunk()) != null)
                            {
                                if (respStatus == null)
                                {
                                    respStatus = HttpResponseInfo.GetResponseStatus(chunk);
                                }
                                DataWrite(chunk, 0, chunk.Length);
                            }
                            reqInfo.ResponseLength = data.ResponseSize;
                        }

                        reqInfo.ResponseStatus = respStatus;
                        isResponseChanged      = true;
                    }
                }                //critical section ends

                if (isResponseChanged && ResponseChanged != null)
                {
                    ResponseChanged.Invoke(
                        new TVDataAccessorDataArgs(requestId, reqInfo));
                }
            }
            catch (Exception ex)
            {
                SdkSettings.Instance.Logger.Log(TraceLevel.Error, "Error saving response data for request id: {0} . Stack trace: {1}", requestId, ex.ToString());
            }
        }