Beispiel #1
0
        int StreamCloseCallback(IntPtr stream)
        {
            int         result = 0;
            StreamState state;

            try
            {
                Ensure.ArgumentNotZeroIntPtr(stream, "stream");

                if (!activeStreams.TryGetValue(stream, out state))
                {
                    throw new ArgumentException("Unknown stream pointer", "stream");
                }

                Ensure.ArgumentIsExpectedIntPtr(stream, state.thisPtr, "stream");

                using (BufferedStream outputBuffer = new BufferedStream(state.output, BufferSize))
                {
                    Complete(state.filterSource.Path, state.filterSource.Root, outputBuffer);
                }

                result = state.nextStream.close(state.nextPtr);
            }
            catch (Exception exception)
            {
                Log.Write(LogLevel.Error, "Filter.StreamCloseCallback exception");
                Log.Write(LogLevel.Error, exception.ToString());
                Proxy.giterr_set_str(GitErrorCategory.Filter, exception);
                result = (int)GitErrorCode.Error;
            }

            return(result);
        }
Beispiel #2
0
        int StreamCloseCallback(IntPtr stream)
        {
            int result = 0;

            try
            {
                Ensure.ArgumentNotZeroIntPtr(stream, "stream");
                Ensure.ArgumentIsExpectedIntPtr(stream, thisPtr, "stream");

                using (BufferedStream outputBuffer = new BufferedStream(output, BufferSize))
                {
                    Complete(filterSource.Path, filterSource.Root, outputBuffer);
                }
            }
            catch (Exception exception)
            {
                Log.Write(LogLevel.Error, "Filter.StreamCloseCallback exception");
                Log.Write(LogLevel.Error, exception.ToString());
                Proxy.giterr_set_str(GitErrorCategory.Filter, exception);
                result = (int)GitErrorCode.Error;
            }

            result = nextStream.close(nextPtr);

            return(result);
        }
Beispiel #3
0
        void StreamFreeCallback(IntPtr stream)
        {
            try
            {
                Ensure.ArgumentNotZeroIntPtr(stream, "stream");
                Ensure.ArgumentIsExpectedIntPtr(stream, thisPtr, "stream");

                Marshal.FreeHGlobal(thisPtr);
            }
            catch (Exception exception)
            {
                Log.Write(LogLevel.Error, "Filter.StreamFreeCallback exception");
                Log.Write(LogLevel.Error, exception.ToString());
            }
        }
Beispiel #4
0
        unsafe int StreamWriteCallback(IntPtr stream, IntPtr buffer, UIntPtr len)
        {
            int         result = 0;
            StreamState state;

            try
            {
                Ensure.ArgumentNotZeroIntPtr(stream, "stream");
                Ensure.ArgumentNotZeroIntPtr(buffer, "buffer");

                if (!activeStreams.TryGetValue(stream, out state))
                {
                    throw new ArgumentException("Invalid or already freed stream pointer", "stream");
                }

                Ensure.ArgumentIsExpectedIntPtr(stream, state.thisPtr, "stream");

                using (UnmanagedMemoryStream input = new UnmanagedMemoryStream((byte *)buffer.ToPointer(), (long)len))
                    using (BufferedStream outputBuffer = new BufferedStream(state.output, BufferSize))
                    {
                        switch (state.filterSource.SourceMode)
                        {
                        case FilterMode.Clean:
                            Clean(state.filterSource.Path, state.filterSource.Root, input, outputBuffer);
                            break;

                        case FilterMode.Smudge:
                            Smudge(state.filterSource.Path, state.filterSource.Root, input, outputBuffer);
                            break;

                        default:
                            Proxy.giterr_set_str(GitErrorCategory.Filter, "Unexpected filter mode.");
                            return((int)GitErrorCode.Ambiguous);
                        }
                    }
            }
            catch (Exception exception)
            {
                Log.Write(LogLevel.Error, "Filter.StreamWriteCallback exception");
                Log.Write(LogLevel.Error, exception.ToString());
                Proxy.giterr_set_str(GitErrorCategory.Filter, exception);
                result = (int)GitErrorCode.Error;
            }

            return(result);
        }
Beispiel #5
0
        void StreamFreeCallback(IntPtr stream)
        {
            StreamState state;

            try
            {
                Ensure.ArgumentNotZeroIntPtr(stream, "stream");

                if (!activeStreams.TryRemove(stream, out state))
                {
                    throw new ArgumentException("Double free or invalid stream pointer", "stream");
                }

                Ensure.ArgumentIsExpectedIntPtr(stream, state.thisPtr, "stream");

                Marshal.FreeHGlobal(state.thisPtr);
            }
            catch (Exception exception)
            {
                Log.Write(LogLevel.Error, "Filter.StreamFreeCallback exception");
                Log.Write(LogLevel.Error, exception.ToString());
            }
        }