Пример #1
0
        public override Task <BLIPMessage> HandleResponseStage(BLIPMessage message, bool fromClient)
        {
            var response = new BLIPMessage
            {
                Type          = MessageType.Response,
                MessageNumber = message.MessageNumber
            };
            var usedRules = new List <Rule>();

            foreach (var rule in ParsedConfig !.Rules)
            {
                if (!IsValidDirection(fromClient, rule.RuleDirection) || !rule.Criteria.Matches(message))
                {
                    continue;
                }

                foreach (var transform in rule.OutputTransforms)
                {
                    Log.Verbose("Applying rule for message {0} ({1})",
                                fromClient ? "from client" : "from server",
                                transform);
                    transform.Transform(ref response);
                }

                usedRules.Add(rule);
            }

            foreach (var rule in usedRules)
            {
                ParsedConfig.Used(rule);
            }

            return(usedRules.Any() ? Task.FromResult(response) : Task.FromResult(default(BLIPMessage)));
        }
Пример #2
0
        public void ApplyMessage(BLIPMessage message)
        {
            blip_message_t *msg = this;

            if (message.Body != null)
            {
                _hasExtra = true;
                var newBody = Marshal.AllocHGlobal(message.Body?.Length ?? 0);
                Marshal.Copy(message.Body !, 0, newBody, message.Body !.Length);
                msg->body_size = (ulong)message.Body.Length;
                msg->body      = (byte *)newBody.ToPointer();
            }
            else
            {
                msg->body      = null;
                msg->body_size = 0;
            }

            if (message.Properties != null)
            {
                _hasExtra = true;
                var newProps = Marshal.StringToCoTaskMemUTF8(message.Properties);
                msg->properties = (byte *)newProps.ToPointer();
            }
            else
            {
                msg->properties = null;
            }

            msg->msg_no = message.MessageNumber;
            msg->flags  = message.Flags;
            msg->type   = message.Type;
        }
        public override Task HandleMessageStage(ref BLIPMessage message, bool fromClient)
        {
            var before = message.Flags;

            message.Flags &= ~FrameFlags.Compressed;
            var after = message.Flags;

            if (before != after)
            {
                Log.Information("Disabled compression on {0} #{1} {2}", message.Type, message.MessageNumber,
                                fromClient ? "to server" : "to client");
            }
            else
            {
                Log.Verbose("Ignored non-compressed {0} #{1} {2}, ", message.Type, message.MessageNumber,
                            fromClient ? "to server" : "to client");
            }

            return(Task.CompletedTask);
        }
Пример #4
0
        public BLIPMessage CreateMessage()
        {
            blip_message_t *msg    = this;
            var             retVal = new BLIPMessage
            {
                Body          = new byte[msg->body_size],
                Checksum      = msg->checksum,
                Flags         = msg->flags,
                MessageNumber = msg->msg_no,
                Type          = msg->type
            };

            if (msg->properties != null)
            {
                retVal.Properties = Marshal.PtrToStringUTF8((IntPtr)msg->properties);
            }

            Marshal.Copy((IntPtr)msg->body, retVal.Body, 0, (int)msg->body_size);
            return(retVal);
        }