diff --git a/internal/bbsim/api/onus_handler.go b/internal/bbsim/api/onus_handler.go
index 7b7d6ce..cec8803 100644
--- a/internal/bbsim/api/onus_handler.go
+++ b/internal/bbsim/api/onus_handler.go
@@ -160,6 +160,46 @@
 	return res, nil
 }
 
+func (s BBSimServer) ChangeIgmpState(ctx context.Context, req *bbsim.IgmpRequest) (*bbsim.Response, error) {
+	res := &bbsim.Response{}
+
+	logger.WithFields(log.Fields{
+		"OnuSn":     req.OnuReq.SerialNumber,
+		"subAction": req.SubActionVal,
+	}).Infof("Received igmp request for ONU")
+
+	olt := devices.GetOLT()
+	onu, err := olt.FindOnuBySn(req.OnuReq.SerialNumber)
+
+	if err != nil {
+		res.StatusCode = int32(codes.NotFound)
+		res.Message = err.Error()
+		fmt.Println("ONU not found for sending igmp packet.")
+		return res, err
+	} else {
+		event := ""
+		switch req.SubActionVal {
+		case bbsim.SubActionTypes_JOIN:
+			event = "igmp_join_start"
+		case bbsim.SubActionTypes_LEAVE:
+			event = "igmp_leave"
+		}
+
+		if igmpErr := onu.InternalState.Event(event); igmpErr != nil {
+			logger.WithFields(log.Fields{
+				"OnuId":  onu.ID,
+				"IntfId": onu.PonPortID,
+				"OnuSn":  onu.Sn(),
+			}).Errorf("IGMP request failed: %s", igmpErr.Error())
+			res.StatusCode = int32(codes.FailedPrecondition)
+			res.Message = err.Error()
+			return res, igmpErr
+		}
+	}
+
+	return res, nil
+}
+
 func (s BBSimServer) RestartEapol(ctx context.Context, req *bbsim.ONURequest) (*bbsim.Response, error) {
 	res := &bbsim.Response{}
 
diff --git a/internal/bbsim/devices/messageTypes.go b/internal/bbsim/devices/messageTypes.go
index fd1d4dc..94c0731 100644
--- a/internal/bbsim/devices/messageTypes.go
+++ b/internal/bbsim/devices/messageTypes.go
@@ -43,7 +43,11 @@
 	SendDhcpFlow   MessageType = 13
 	OnuPacketIn    MessageType = 14
 
-	AlarmIndication MessageType = 15 // message data is an openolt.AlarmIndication
+	//IGMP
+	IGMPMembershipReportV2 MessageType = 15 // Version 2 Membership Report (JOIN)
+	IGMPLeaveGroup         MessageType = 16 // Leave Group
+
+	AlarmIndication MessageType = 17 // message data is an openolt.AlarmIndication
 )
 
 func (m MessageType) String() string {
@@ -63,6 +67,8 @@
 		"SendEapolFlow",
 		"SendDhcpFlow",
 		"OnuPacketIn",
+		"IGMPMembershipReportV2",
+		"IGMPLeaveGroup",
 	}
 	return names[m]
 }
diff --git a/internal/bbsim/devices/onu.go b/internal/bbsim/devices/onu.go
index 2ec674c..c9c2f17 100644
--- a/internal/bbsim/devices/onu.go
+++ b/internal/bbsim/devices/onu.go
@@ -30,6 +30,7 @@
 	"github.com/opencord/bbsim/internal/bbsim/packetHandlers"
 	"github.com/opencord/bbsim/internal/bbsim/responders/dhcp"
 	"github.com/opencord/bbsim/internal/bbsim/responders/eapol"
+	"github.com/opencord/bbsim/internal/bbsim/responders/igmp"
 	"github.com/opencord/bbsim/internal/common"
 	omcilib "github.com/opencord/bbsim/internal/common/omci"
 	omcisim "github.com/opencord/omci-sim"
@@ -138,6 +139,11 @@
 			// TODO add start OMCI state
 			{Name: "send_eapol_flow", Src: []string{"initialized"}, Dst: "eapol_flow_sent"},
 			{Name: "send_dhcp_flow", Src: []string{"eapol_flow_sent"}, Dst: "dhcp_flow_sent"},
+			// IGMP
+			{Name: "igmp_join_start", Src: []string{"eap_response_success_received", "gem_port_added", "eapol_flow_received"}, Dst: "igmp_join_start"},
+			{Name: "igmp_join_done", Src: []string{"igmp_join_start"}, Dst: "igmp_join_done"},
+			{Name: "igmp_join_error", Src: []string{"igmp_join_start"}, Dst: "igmp_join_error"},
+			{Name: "igmp_leave", Src: []string{"igmp_join_start"}, Dst: "igmp_left"},
 		},
 		fsm.Callbacks{
 			"enter_state": func(e *fsm.Event) {
@@ -237,6 +243,17 @@
 				}
 				o.Channel <- msg
 			},
+			"igmp_join_start": func(e *fsm.Event) {
+				msg := Message{
+					Type: IGMPMembershipReportV2,
+				}
+				o.Channel <- msg
+			},
+			"igmp_leave": func(e *fsm.Event) {
+				msg := Message{
+					Type: IGMPLeaveGroup}
+				o.Channel <- msg
+			},
 		},
 	)
 
@@ -348,6 +365,12 @@
 				o.sendEapolFlow(client)
 			case SendDhcpFlow:
 				o.sendDhcpFlow(client)
+			case IGMPMembershipReportV2:
+				log.Infof("Recieved IGMPMembershipReportV2 message on ONU channel")
+				igmp.SendIGMPMembershipReportV2(o.PonPortID, o.ID, o.Sn(), o.PortNo, o.HwAddress, stream)
+			case IGMPLeaveGroup:
+				log.Infof("Recieved IGMPLeaveGroupV2 message on ONU channel")
+				igmp.SendIGMPLeaveGroupV2(o.PonPortID, o.ID, o.Sn(), o.PortNo, o.HwAddress, stream)
 			default:
 				onuLogger.Warnf("Received unknown message data %v for type %v in OLT Channel", message.Data, message.Type)
 			}
diff --git a/internal/bbsim/responders/igmp/igmp.go b/internal/bbsim/responders/igmp/igmp.go
new file mode 100644
index 0000000..cfdb079
--- /dev/null
+++ b/internal/bbsim/responders/igmp/igmp.go
@@ -0,0 +1,250 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ * 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 igmp
+
+import (
+	"encoding/binary"
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	bbsim "github.com/opencord/bbsim/internal/bbsim/types"
+	omci "github.com/opencord/omci-sim"
+	"github.com/opencord/voltha-protos/v2/go/openolt"
+	log "github.com/sirupsen/logrus"
+	"net"
+	"time"
+)
+
+func SendIGMPLeaveGroupV2(ponPortId uint32, onuId uint32, serialNumber string, portNo uint32, macAddress net.HardwareAddr, stream bbsim.Stream) error {
+	log.WithFields(log.Fields{
+		"OnuId":        onuId,
+		"SerialNumber": serialNumber,
+		"PortNo":       portNo,
+	}).Debugf("Entered SendIGMPLeaveGroupV2")
+	igmp := createIGMPV2LeaveRequestPacket()
+	pkt, err := serializeIgmpPacket(ponPortId, onuId, macAddress, igmp)
+
+	if err != nil {
+		log.WithFields(log.Fields{
+			"OnuId":        onuId,
+			"IntfId":       ponPortId,
+			"SerialNumber": serialNumber,
+		}).Errorf("Seriliazation of igmp packet failed :  %s", err)
+		return err
+	}
+
+	gemid, err := omci.GetGemPortId(ponPortId, onuId)
+	if err != nil {
+		log.WithFields(log.Fields{
+			"OnuId":        onuId,
+			"IntfId":       ponPortId,
+			"SerialNumber": serialNumber,
+		}).Errorf("Can't retrieve GemPortId for IGMP: %s", err)
+		return err
+	}
+
+	data := &openolt.Indication_PktInd{
+		PktInd: &openolt.PacketIndication{
+			IntfType:  "pon",
+			IntfId:    ponPortId,
+			GemportId: uint32(gemid),
+			Pkt:       pkt,
+			PortNo:    portNo,
+		},
+	}
+	//Sending IGMP packets
+	if err := stream.Send(&openolt.Indication{Data: data}); err != nil {
+		log.Errorf("Fail to send IGMP PktInd indication for ONU: %s, IntfId: %s, SerialNumber: %s,  error: %v", onuId, ponPortId, serialNumber, err)
+		return err
+	}
+	return nil
+}
+
+func SendIGMPMembershipReportV2(ponPortId uint32, onuId uint32, serialNumber string, portNo uint32, macAddress net.HardwareAddr, stream bbsim.Stream) error {
+	log.WithFields(log.Fields{
+		"OnuId":        onuId,
+		"SerialNumber": serialNumber,
+		"PortNo":       portNo,
+	}).Debugf("Entered SendIGMPMembershipReportV2")
+	igmp := createIGMPV2MembershipReportPacket()
+	pkt, err := serializeIgmpPacket(ponPortId, onuId, macAddress, igmp)
+
+	if err != nil {
+		log.WithFields(log.Fields{
+			"OnuId":        onuId,
+			"IntfId":       ponPortId,
+			"SerialNumber": serialNumber,
+		}).Errorf("Seriliazation of igmp packet failed :  %s", err)
+		return err
+	}
+
+	gemid, err := omci.GetGemPortId(ponPortId, onuId)
+	if err != nil {
+		log.WithFields(log.Fields{
+			"OnuId":        onuId,
+			"IntfId":       ponPortId,
+			"SerialNumber": serialNumber,
+		}).Errorf("Can't retrieve GemPortId for IGMP: %s", err)
+		return err
+	}
+
+	data := &openolt.Indication_PktInd{
+		PktInd: &openolt.PacketIndication{
+			IntfType:  "pon",
+			IntfId:    ponPortId,
+			GemportId: uint32(gemid),
+			Pkt:       pkt,
+			PortNo:    portNo,
+		},
+	}
+	//Sending IGMP packets
+	if err := stream.Send(&openolt.Indication{Data: data}); err != nil {
+		log.Errorf("Fail to send IGMP PktInd indication for ONU: %s, IntfId: %s, SerialNumber: %s,  error: %v", onuId, ponPortId, serialNumber, err)
+		return err
+	}
+	return nil
+}
+
+//func serializeIgmpPacket(intfId uint32, onuId uint32, srcMac net.HardwareAddr, igmp *layers.IGMP) ([]byte, error) {
+func createIGMPV2MembershipReportPacket() IGMP {
+	return IGMP{
+		Type:            0x16, //IGMPV2 Membership Report
+		MaxResponseTime: time.Duration(1),
+		Checksum:        0,
+		GroupAddress:    net.IPv4(224, 0, 0, 22),
+		Version:         2,
+	}
+}
+
+func createIGMPV2LeaveRequestPacket() IGMP {
+	return IGMP{
+		Type:            0x17, //IGMPV2 Leave Group
+		MaxResponseTime: time.Duration(1),
+		Checksum:        0,
+		GroupAddress:    net.IPv4(224, 0, 0, 22),
+		Version:         2,
+	}
+}
+
+func serializeIgmpPacket(intfId uint32, onuId uint32, srcMac net.HardwareAddr, igmp IGMP) ([]byte, error) {
+	buffer := gopacket.NewSerializeBuffer()
+	options := gopacket.SerializeOptions{
+		ComputeChecksums: true,
+		FixLengths:       true,
+	}
+
+	ethernetLayer := &layers.Ethernet{
+		SrcMAC:       srcMac,
+		DstMAC:       net.HardwareAddr{0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
+		EthernetType: layers.EthernetTypeIPv4,
+	}
+
+	ipLayer := &layers.IPv4{
+		Version:  4,
+		TOS:      0x10,
+		Id:       0,
+		TTL:      128,
+		SrcIP:    []byte{0, 0, 0, 0},
+		DstIP:    []byte{224, 0, 0, 22},
+		Protocol: layers.IPProtocolIGMP,
+		Options:  []layers.IPv4Option{{OptionType: 148, OptionLength: 4, OptionData: make([]byte, 0)}}, //Adding router alert option
+	}
+
+	if err := gopacket.SerializeLayers(buffer, options, ethernetLayer, ipLayer, igmp); err != nil {
+		return nil, err
+	}
+
+	return buffer.Bytes(), nil
+}
+
+//-----------------------------------------***********************---------------------------------
+// BaseLayer is a convenience struct which implements the LayerData and
+// LayerPayload functions of the Layer interface.
+type BaseLayer struct {
+	// Contents is the set of bytes that make up this layer.  IE: for an
+	// Ethernet packet, this would be the set of bytes making up the
+	// Ethernet frame.
+	Contents []byte
+	// Payload is the set of bytes contained by (but not part of) this
+	// Layer.  Again, to take Ethernet as an example, this would be the
+	// set of bytes encapsulated by the Ethernet protocol.
+	Payload []byte
+}
+
+type IGMPType uint8
+
+type IGMP struct {
+	BaseLayer
+	Type                    IGMPType
+	MaxResponseTime         time.Duration
+	Checksum                uint16
+	GroupAddress            net.IP
+	SupressRouterProcessing bool
+	RobustnessValue         uint8
+	IntervalTime            time.Duration
+	SourceAddresses         []net.IP
+	NumberOfGroupRecords    uint16
+	NumberOfSources         uint16
+	Version                 uint8 // IGMP protocol version
+}
+
+// SerializeTo writes the serialized form of this layer into the
+// SerializationBuffer, implementing gopacket.SerializableLayer.
+// See the docs for gopacket.SerializableLayer for more info.
+// SerializeTo writes the serialized form of this layer into the
+// SerializationBuffer, implementing gopacket.SerializableLayer.
+// See the docs for gopacket.SerializableLayer for more info.
+func (igmp IGMP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	//	func (igmp *IGMP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	log.Debugf("Serializing IGMP Packet")
+	//TODO - add  length check here
+	data, err := b.PrependBytes(8915)
+	if err != nil {
+		return err
+	}
+
+	data[0] = byte(igmp.Type)
+	data[1] = byte(igmp.MaxResponseTime)
+	data[2] = 0
+	data[3] = 0
+	copy(data[4:8], igmp.GroupAddress.To4())
+	if opts.ComputeChecksums {
+		igmp.Checksum = tcpipChecksum(data, 0)
+		binary.BigEndian.PutUint16(data[2:4], igmp.Checksum)
+	}
+	return nil
+}
+
+// Calculate the TCP/IP checksum defined in rfc1071.  The passed-in csum is any
+// initial checksum data that's already been computed.
+func tcpipChecksum(data []byte, csum uint32) uint16 {
+	// to handle odd lengths, we loop to length - 1, incrementing by 2, then
+	// handle the last byte specifically by checking against the original
+	// length.
+	length := len(data) - 1
+	for i := 0; i < length; i += 2 {
+		// For our test packet, doing this manually is about 25% faster
+		// (740 ns vs. 1000ns) than doing it by calling binary.BigEndian.Uint16.
+		csum += uint32(data[i]) << 8
+		csum += uint32(data[i+1])
+	}
+	if len(data)%2 == 1 {
+		csum += uint32(data[length]) << 8
+	}
+	for csum > 0xffff {
+		csum = (csum >> 16) + (csum & 0xffff)
+	}
+	return ^uint16(csum)
+}
+
+func (IGMP) LayerType() gopacket.LayerType { return layers.LayerTypeIGMP }
diff --git a/internal/bbsimctl/commands/onu.go b/internal/bbsimctl/commands/onu.go
index 620e052..515ba07 100644
--- a/internal/bbsimctl/commands/onu.go
+++ b/internal/bbsimctl/commands/onu.go
@@ -35,6 +35,11 @@
 )
 
 type OnuSnString string
+type IgmpSubAction string
+
+const IgmpJoinKey string = "join"
+const IgmpLeaveKey string = "leave"
+
 type ONUList struct{}
 
 type ONUGet struct {
@@ -67,6 +72,13 @@
 	} `positional-args:"yes" required:"yes"`
 }
 
+type ONUIgmp struct {
+	Args struct {
+		OnuSn     OnuSnString
+		SubAction IgmpSubAction
+	} `positional-args:"yes" required:"yes"`
+}
+
 type ONUOptions struct {
 	List         ONUList         `command:"list"`
 	Get          ONUGet          `command:"get"`
@@ -74,6 +86,7 @@
 	PowerOn      ONUPowerOn      `command:"poweron"`
 	RestartEapol ONUEapolRestart `command:"auth_restart"`
 	RestartDchp  ONUDhcpRestart  `command:"dhcp_restart"`
+	Igmp         ONUIgmp         `command:"igmp"`
 }
 
 func RegisterONUCommands(parser *flags.Parser) {
@@ -228,6 +241,53 @@
 	return nil
 }
 
+func (options *ONUIgmp) Execute(args []string) error {
+	client, conn := connect()
+	defer conn.Close()
+
+	ctx, cancel := context.WithTimeout(context.Background(), config.GlobalConfig.Grpc.Timeout)
+	defer cancel()
+
+	req := pb.ONURequest{
+		SerialNumber: string(options.Args.OnuSn),
+	}
+
+	var subActionVal pb.SubActionTypes
+	if string(options.Args.SubAction) == IgmpJoinKey {
+		subActionVal = pb.SubActionTypes_JOIN
+	} else if string(options.Args.SubAction) == IgmpLeaveKey {
+		subActionVal = pb.SubActionTypes_LEAVE
+	}
+
+	igmpReq := pb.IgmpRequest{
+		OnuReq:       &req,
+		SubActionVal: subActionVal,
+	}
+	res, err := client.GetONU(ctx, igmpReq.OnuReq)
+	if err != nil {
+		log.WithFields(log.Fields{
+			"SerialNumber": options.Args.OnuSn,
+		}).Errorf("Cannot not get details on ONU error: %v", err)
+	}
+	log.WithFields(log.Fields{
+		"SerialNumber": igmpReq.OnuReq.SerialNumber,
+	}).Debugf("ONU has indentified : %s", res)
+
+	igmpRes, igmpErr := client.ChangeIgmpState(ctx, &igmpReq)
+	if igmpErr != nil {
+		log.WithFields(log.Fields{
+			"SubAction": options.Args.SubAction,
+		}).Errorf("Could not process Action: error: %v", igmpErr)
+	} else {
+		log.WithFields(log.Fields{
+			"SubAction": options.Args.SubAction,
+		}).Debugf("igmp state has been changed with response: %s",
+			igmpRes.Message)
+	}
+
+	return nil
+}
+
 func (onuSn *OnuSnString) Complete(match string) []flags.Completion {
 	client, conn := connect()
 	defer conn.Close()