diff --git a/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BgpMessageVer4.java b/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BgpMessageVer4.java
new file mode 100755
index 0000000..1c05dae
--- /dev/null
+++ b/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BgpMessageVer4.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.bgpio.protocol.ver4;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.bgpio.exceptions.BgpParseException;
+import org.onosproject.bgpio.protocol.BgpFactories;
+import org.onosproject.bgpio.protocol.BgpMessage;
+import org.onosproject.bgpio.protocol.BgpMessageReader;
+import org.onosproject.bgpio.types.BgpErrorType;
+import org.onosproject.bgpio.types.BgpHeader;
+import org.onosproject.bgpio.util.Validation;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Provides BGP messages.
+ */
+public abstract class BgpMessageVer4 {
+
+    protected static final Logger log = LoggerFactory.getLogger(BgpFactories.class);
+
+    static final byte OPEN_MSG_TYPE = 0x1;
+    static final byte KEEPALIVE_MSG_TYPE = 0x4;
+    static final byte UPDATE_MSG_TYPE = 0x2;
+    static final byte NOTIFICATION_MSG_TYPE = 0x3;
+    static final int MINIMUM_COMMON_HEADER_LENGTH = 19;
+    static final int HEADER_AND_MSG_LEN = 18;
+    static final int MAXIMUM_PACKET_LENGTH = 4096;
+
+    public static final BgpMessageVer4.Reader READER = new Reader();
+
+    /**
+     * Reader class for reading BGP messages from channel buffer.
+     *
+     */
+    static class Reader implements BgpMessageReader<BgpMessage> {
+        @Override
+        public BgpMessage readFrom(ChannelBuffer cb, BgpHeader bgpHeader)
+                throws BgpParseException {
+
+            if (cb.readableBytes() < MINIMUM_COMMON_HEADER_LENGTH) {
+                log.error("Packet should have minimum length.");
+                Validation.validateLen(BgpErrorType.MESSAGE_HEADER_ERROR, BgpErrorType.BAD_MESSAGE_LENGTH,
+                                       cb.readableBytes());
+            }
+            if (cb.readableBytes() > MAXIMUM_PACKET_LENGTH) {
+                log.error("Packet length should not exceed {}.", MAXIMUM_PACKET_LENGTH);
+                Validation.validateLen(BgpErrorType.MESSAGE_HEADER_ERROR, BgpErrorType.BAD_MESSAGE_LENGTH,
+                                       cb.readableBytes());
+            }
+            try {
+                // fixed value property version == 4
+                byte[] marker = new byte[BgpHeader.MARKER_LENGTH];
+                cb.readBytes(marker, 0, BgpHeader.MARKER_LENGTH);
+                bgpHeader.setMarker(marker);
+                for (int i = 0; i < BgpHeader.MARKER_LENGTH; i++) {
+                    if (marker[i] != (byte) 0xff) {
+                        throw new BgpParseException(BgpErrorType.MESSAGE_HEADER_ERROR,
+                                                    BgpErrorType.CONNECTION_NOT_SYNCHRONIZED, null);
+                    }
+                }
+                short length = cb.readShort();
+                if (length > cb.readableBytes() + HEADER_AND_MSG_LEN) {
+                    Validation.validateLen(BgpErrorType.MESSAGE_HEADER_ERROR,
+                                           BgpErrorType.BAD_MESSAGE_LENGTH, length);
+                }
+                bgpHeader.setLength(length);
+                byte type = cb.readByte();
+                bgpHeader.setType(type);
+                log.debug("Reading update message of type " + type);
+
+                int len = length - MINIMUM_COMMON_HEADER_LENGTH;
+                switch (type) {
+                case OPEN_MSG_TYPE:
+                    log.debug("OPEN MESSAGE is received");
+                    return BgpOpenMsgVer4.READER.readFrom(cb.readBytes(len), bgpHeader);
+                case KEEPALIVE_MSG_TYPE:
+                    log.debug("KEEPALIVE MESSAGE is received");
+                    return BgpKeepaliveMsgVer4.READER.readFrom(cb.readBytes(len), bgpHeader);
+                case UPDATE_MSG_TYPE:
+                    log.debug("UPDATE MESSAGE is received");
+                    return BgpUpdateMsgVer4.READER.readFrom(cb.readBytes(len), bgpHeader);
+                case NOTIFICATION_MSG_TYPE:
+                    log.debug("NOTIFICATION MESSAGE is received");
+                    return BgpNotificationMsgVer4.READER.readFrom(cb.readBytes(len), bgpHeader);
+                default:
+                    Validation.validateType(BgpErrorType.MESSAGE_HEADER_ERROR, BgpErrorType.BAD_MESSAGE_TYPE, type);
+                    return null;
+                }
+            } catch (IndexOutOfBoundsException e) {
+                throw new BgpParseException(BgpErrorType.MESSAGE_HEADER_ERROR,
+                                            BgpErrorType.BAD_MESSAGE_LENGTH, null);
+            }
+        }
+    }
+}
\ No newline at end of file