Breaking change: rework method prototypes to match golang conventions

louisroyer · louisroyer · commit 7b8fe7a6c0d1 · 2026-01-11T21:16:36.000+01:00
diff --git a/README.md b/README.md
@@ -27,7 +27,7 @@ ctx := context.TODO()
 cpNode := NewPFCPEntityCP(SMF_NODE_ID, SMF_IP_ADDR) // node id can be an IP Address or a FQDN
 go cpNode.ListenAndServeContext(ctx)
 cpNode.WaitReady(ctx)
-association, _ := cpNode.NewEstablishedPFCPAssociation(ie.NewNodeIDHeuristic(UPFADDR))
+association, _ := cpNode.NewEstablishedPFCPAssociation(ctx, ie.NewNodeIDHeuristic(UPFADDR))
 session, _ := a.CreateSession(pdrs, fars)
 
 ```
diff --git a/pfcp/api/association_interface.go b/pfcp/api/association_interface.go
@@ -6,13 +6,15 @@
 package api
 
 import (
+	"context"
+
 	"github.com/wmnsk/go-pfcp/ie"
 )
 
 type SEID = uint64
 type PFCPAssociationInterface interface {
 	PFCPPeerInterface
-	SetupInitiatedByCP() error
+	SetupInitiatedByCP(ctx context.Context) error
 	GetNextSEID() SEID
-	CreateSession(remoteFseid *ie.IE, pdrs PDRMapInterface, fars FARMapInterface) (session PFCPSessionInterface, err error)
+	CreateSession(ctx context.Context, remoteFseid *ie.IE, pdrs PDRMapInterface, fars FARMapInterface) (session PFCPSessionInterface, err error)
 }
diff --git a/pfcp/api/entity_interface.go b/pfcp/api/entity_interface.go
@@ -18,7 +18,7 @@ type PFCPEntityInterface interface {
 	IsControlPlane() bool
 	NodeID() *ie.IE
 	RecoveryTimeStamp() *ie.IE
-	NewEstablishedPFCPAssociation(nodeID *ie.IE) (association PFCPAssociationInterface, err error)
+	NewEstablishedPFCPAssociation(ctx context.Context, nodeID *ie.IE) (association PFCPAssociationInterface, err error)
 	RemovePFCPAssociation(association PFCPAssociationInterface) error
 	GetPFCPAssociation(nid string) (association PFCPAssociationInterface, err error)
 	GetPFCPSessions() []PFCPSessionInterface
diff --git a/pfcp/api/peer_interface.go b/pfcp/api/peer_interface.go
@@ -6,6 +6,8 @@
 package api
 
 import (
+	"context"
+
 	"github.com/wmnsk/go-pfcp/ie"
 	"github.com/wmnsk/go-pfcp/message"
 )
@@ -19,5 +21,5 @@ type PFCPPeerInterface interface {
 	IsUserPlane() bool
 	IsControlPlane() bool
 	LocalEntity() PFCPEntityInterface
-	NewEstablishedPFCPAssociation() (PFCPAssociationInterface, error)
+	NewEstablishedPFCPAssociation(ctx context.Context) (PFCPAssociationInterface, error)
 }
diff --git a/pfcp/association.go b/pfcp/association.go
@@ -6,6 +6,7 @@
 package pfcp_networking
 
 import (
+	"context"
 	"fmt"
 	"net"
 	"time"
@@ -23,14 +24,13 @@ type PFCPAssociation struct {
 }
 
 // Create a new PFCPAssociation, this association is already set-up
-func newEstablishedPFCPAssociation(peer api.PFCPPeerInterface) (api.PFCPAssociationInterface, error) {
+func newEstablishedPFCPAssociation(ctx context.Context, peer api.PFCPPeerInterface) (api.PFCPAssociationInterface, error) {
 	association := PFCPAssociation{
 		PFCPPeerInterface: peer,
 		isSetup:           false,
 		sessionIDPool:     NewSessionIDPool(),
 	}
-	err := association.SetupInitiatedByCP()
-	if err != nil {
+	if err := association.SetupInitiatedByCP(ctx); err != nil {
 		return nil, err
 	}
 	return &association, nil
@@ -57,14 +57,14 @@ func (association *PFCPAssociation) GetNextSEID() api.SEID {
 // clause 6.2.6.3).
 // The CP function and the UP function shall support the PFCP Association Setup initiated by the CP function. The CP
 // function and the UP function may additionally support the PFCP Association Setup initiated by the UP function.
-func (association *PFCPAssociation) SetupInitiatedByCP() error {
+func (association *PFCPAssociation) SetupInitiatedByCP(ctx context.Context) error {
 	if association.isSetup {
 		return fmt.Errorf("association is already set up")
 	}
 	switch {
 	case association.LocalEntity().IsUserPlane():
 		association.isSetup = true
-		go association.heartMonitoring()
+		go association.heartMonitoring(ctx)
 		return nil
 	case association.LocalEntity().IsControlPlane():
 		sar := message.NewAssociationSetupRequest(0, association.LocalEntity().NodeID(), association.LocalEntity().RecoveryTimeStamp())
@@ -83,7 +83,7 @@ func (association *PFCPAssociation) SetupInitiatedByCP() error {
 		}
 		if cause == ie.CauseRequestAccepted {
 			association.isSetup = true
-			go association.heartMonitoring()
+			go association.heartMonitoring(ctx)
 			return nil
 		}
 		return fmt.Errorf("association setup request rejected")
@@ -93,7 +93,7 @@ func (association *PFCPAssociation) SetupInitiatedByCP() error {
 }
 
 // Start monitoring heart of a PFCP Association
-func (association *PFCPAssociation) heartMonitoring() error {
+func (association *PFCPAssociation) heartMonitoring(ctx context.Context) error {
 	defer association.Close()
 	checkInterval := 30 * time.Second
 	for {
@@ -106,6 +106,8 @@ func (association *PFCPAssociation) heartMonitoring() error {
 			if err != nil {
 				return err
 			}
+		case <-ctx.Done():
+			return ctx.Err()
 		}
 	}
 }
@@ -158,7 +160,7 @@ func (association *PFCPAssociation) getFSEID(seid api.SEID) (*ie.IE, error) {
 }
 
 // remoteFseid can be nil if caller is at CP function side
-func (association *PFCPAssociation) CreateSession(remoteFseid *ie.IE, pdrs api.PDRMapInterface, fars api.FARMapInterface) (session api.PFCPSessionInterface, err error) {
+func (association *PFCPAssociation) CreateSession(ctx context.Context, remoteFseid *ie.IE, pdrs api.PDRMapInterface, fars api.FARMapInterface) (session api.PFCPSessionInterface, err error) {
 	// Generation of the F-SEID
 	localSEID := association.GetNextSEID()
 	localFseid, err := association.getFSEID(localSEID)
diff --git a/pfcp/entity.go b/pfcp/entity.go
@@ -184,7 +184,7 @@ func (e *PFCPEntity) GetPFCPAssociation(nid string) (association api.PFCPAssocia
 	return e.associationsMap.Get(nid)
 }
 
-func (e *PFCPEntity) NewEstablishedPFCPAssociation(nodeID *ie.IE) (association api.PFCPAssociationInterface, err error) {
+func (e *PFCPEntity) NewEstablishedPFCPAssociation(ctx context.Context, nodeID *ie.IE) (association api.PFCPAssociationInterface, err error) {
 	peer, err := newPFCPPeerUP(e, nodeID)
 	if err != nil {
 		return nil, err
@@ -199,7 +199,7 @@ func (e *PFCPEntity) NewEstablishedPFCPAssociation(nodeID *ie.IE) (association a
 	if !e.associationsMap.CheckNonExist(nid) {
 		return nil, fmt.Errorf("association already exists")
 	}
-	a, err := peer.NewEstablishedPFCPAssociation()
+	a, err := peer.NewEstablishedPFCPAssociation(ctx)
 	if err != nil {
 		return nil, err
 	}
diff --git a/pfcp/far_map.go b/pfcp/far_map.go
@@ -129,7 +129,7 @@ func (m *FARMap) NewCreateFARs() []*ie.IE {
 	return f
 }
 
-func NewFARMap(fars []*ie.IE) (farmap *FARMap, err error, cause uint8, offendingIE uint16) {
+func NewFARMap(fars []*ie.IE) (farmap *FARMap, cause uint8, offendingIE uint16, err error) {
 	f := FARMap{
 		farmap: make(farmapInternal),
 		mu:     sync.RWMutex{},
@@ -139,22 +139,22 @@ func NewFARMap(fars []*ie.IE) (farmap *FARMap, err error, cause uint8, offending
 		if err != nil {
 			switch err {
 			case io.ErrUnexpectedEOF:
-				return nil, err, ie.CauseInvalidLength, ie.FARID
+				return nil, ie.CauseInvalidLength, ie.FARID, err
 			case ie.ErrIENotFound:
-				return nil, err, ie.CauseMandatoryIEMissing, ie.FARID
+				return nil, ie.CauseMandatoryIEMissing, ie.FARID, err
 			default:
-				return nil, err, ie.CauseMandatoryIEIncorrect, ie.CreateFAR
+				return nil, ie.CauseMandatoryIEIncorrect, ie.CreateFAR, err
 			}
 		}
 		aa, err := far.ApplyAction()
 		if err != nil {
 			switch err {
 			case io.ErrUnexpectedEOF:
-				return nil, err, ie.CauseInvalidLength, ie.ApplyAction
+				return nil, ie.CauseInvalidLength, ie.ApplyAction, err
 			case ie.ErrIENotFound:
-				return nil, err, ie.CauseMandatoryIEMissing, ie.ApplyAction
+				return nil, ie.CauseMandatoryIEMissing, ie.ApplyAction, err
 			default:
-				return nil, err, ie.CauseMandatoryIEIncorrect, ie.CreateFAR
+				return nil, ie.CauseMandatoryIEIncorrect, ie.CreateFAR, err
 			}
 		}
 
@@ -170,7 +170,7 @@ func NewFARMap(fars []*ie.IE) (farmap *FARMap, err error, cause uint8, offending
 			hasFP = true
 		}
 		if mustHaveFP && !hasFP {
-			return nil, err, ie.CauseMandatoryIEIncorrect, ie.CreateFAR
+			return nil, ie.CauseMandatoryIEIncorrect, ie.CreateFAR, err
 		}
 
 		if !hasFP {
@@ -179,10 +179,10 @@ func NewFARMap(fars []*ie.IE) (farmap *FARMap, err error, cause uint8, offending
 			err = f.Add(NewFAR(ie.NewFARID(id), ie.NewApplyAction(aa...), ie.NewForwardingParameters(fp...)))
 		}
 		if err != nil {
-			return nil, err, ie.CauseMandatoryIEIncorrect, ie.CreateFAR
+			return nil, ie.CauseMandatoryIEIncorrect, ie.CreateFAR, err
 		}
 	}
-	return &f, nil, 0, 0
+	return &f, 0, 0, nil
 
 }
 
diff --git a/pfcp/far_map_update.go b/pfcp/far_map_update.go
@@ -22,7 +22,7 @@ type FARMapUpdate struct {
 	mu     sync.RWMutex
 }
 
-func NewFARMapUpdate(fars []*ie.IE) (*FARMapUpdate, error, uint8, uint16) {
+func NewFARMapUpdate(fars []*ie.IE) (*FARMapUpdate, uint8, uint16, error) {
 	f := FARMapUpdate{
 		farmap: make(farmapUpdateInternal),
 		mu:     sync.RWMutex{},
@@ -32,11 +32,11 @@ func NewFARMapUpdate(fars []*ie.IE) (*FARMapUpdate, error, uint8, uint16) {
 		if err != nil {
 			switch err {
 			case io.ErrUnexpectedEOF:
-				return nil, err, ie.CauseInvalidLength, ie.FARID
+				return nil, ie.CauseInvalidLength, ie.FARID, err
 			case ie.ErrIENotFound:
-				return nil, err, ie.CauseMandatoryIEMissing, ie.FARID
+				return nil, ie.CauseMandatoryIEMissing, ie.FARID, err
 			default:
-				return nil, err, ie.CauseMandatoryIEIncorrect, ie.CreateFAR
+				return nil, ie.CauseMandatoryIEIncorrect, ie.CreateFAR, err
 			}
 		}
 		var ieaa *ie.IE = nil
@@ -51,7 +51,7 @@ func NewFARMapUpdate(fars []*ie.IE) (*FARMapUpdate, error, uint8, uint16) {
 		}
 		f.Add(NewFARUpdate(ie.NewFARID(id), ieaa, iefp))
 	}
-	return &f, nil, 0, 0
+	return &f, 0, 0, nil
 
 }
 
diff --git a/pfcp/handlers.go b/pfcp/handlers.go
@@ -42,7 +42,7 @@ func DefaultAssociationSetupRequestHandler(ctx context.Context, msg ReceivedMess
 		return nil, fmt.Errorf("entity.RecoveryTimeStamp() is nil")
 	}
 
-	if _, err := msg.Entity.NewEstablishedPFCPAssociation(m.NodeID); err != nil {
+	if _, err := msg.Entity.NewEstablishedPFCPAssociation(ctx, m.NodeID); err != nil {
 		logrus.WithError(err).Debug("Rejected Association")
 		res := message.NewAssociationSetupResponse(msg.Sequence(), msg.Entity.NodeID(), ie.NewCause(ie.CauseRequestRejected), msg.Entity.RecoveryTimeStamp())
 		return msg.NewResponse(res)
@@ -127,21 +127,21 @@ func DefaultSessionEstablishmentRequestHandler(ctx context.Context, msg Received
 	}
 
 	// create PDRs
-	pdrs, err, cause, offendingie := NewPDRMap(m.CreatePDR)
+	pdrs, cause, offendingie, err := NewPDRMap(m.CreatePDR)
 	if err != nil {
 		res := message.NewSessionEstablishmentResponse(0, 0, rseid, msg.Sequence(), 0, msg.Entity.NodeID(), ie.NewCause(cause), ie.NewOffendingIE(offendingie))
 		return msg.NewResponse(res)
 	}
 
 	// create FARs
-	fars, err, cause, offendingie := NewFARMap(m.CreateFAR)
+	fars, cause, offendingie, err := NewFARMap(m.CreateFAR)
 	if err != nil {
 		res := message.NewSessionEstablishmentResponse(0, 0, rseid, msg.Sequence(), 0, msg.Entity.NodeID(), ie.NewCause(cause), ie.NewOffendingIE(offendingie))
 		return msg.NewResponse(res)
 	}
 
 	// create session with PDRs and FARs
-	session, err := association.CreateSession(m.CPFSEID, pdrs, fars)
+	session, err := association.CreateSession(ctx, m.CPFSEID, pdrs, fars)
 	if err != nil {
 		// Send cause(Rule creation/modification failure)
 		res := message.NewSessionEstablishmentResponse(0, 0, rseid, msg.Sequence(), 0, msg.Entity.NodeID(), ie.NewCause(ie.CauseRuleCreationModificationFailure))
@@ -219,28 +219,28 @@ func DefaultSessionModificationRequestHandler(ctx context.Context, msg ReceivedM
 	//XXX: CP F-SEID is ignored for the moment
 
 	// create PDRs
-	createpdrs, err, cause, offendingie := NewPDRMap(m.CreatePDR)
+	createpdrs, cause, offendingie, err := NewPDRMap(m.CreatePDR)
 	if err != nil {
 		res := message.NewSessionEstablishmentResponse(0, 0, rseid, msg.Sequence(), 0, msg.Entity.NodeID(), ie.NewCause(cause), ie.NewOffendingIE(offendingie))
 		return msg.NewResponse(res)
 	}
 
 	// create FARs
-	createfars, err, cause, offendingie := NewFARMap(m.CreateFAR)
+	createfars, cause, offendingie, err := NewFARMap(m.CreateFAR)
 	if err != nil {
 		res := message.NewSessionEstablishmentResponse(0, 0, rseid, msg.Sequence(), 0, msg.Entity.NodeID(), ie.NewCause(cause), ie.NewOffendingIE(offendingie))
 		return msg.NewResponse(res)
 	}
 
 	// update PDRs
-	updatepdrs, err, cause, offendingie := NewPDRMap(m.UpdatePDR)
+	updatepdrs, cause, offendingie, err := NewPDRMap(m.UpdatePDR)
 	if err != nil {
 		res := message.NewSessionEstablishmentResponse(0, 0, rseid, msg.Sequence(), 0, msg.Entity.NodeID(), ie.NewCause(cause), ie.NewOffendingIE(offendingie))
 		return msg.NewResponse(res)
 	}
 
 	// update FARs
-	updatefars, err, cause, offendingie := NewFARMapUpdate(m.UpdateFAR)
+	updatefars, cause, offendingie, err := NewFARMapUpdate(m.UpdateFAR)
 	if err != nil {
 		res := message.NewSessionEstablishmentResponse(0, 0, rseid, msg.Sequence(), 0, msg.Entity.NodeID(), ie.NewCause(cause), ie.NewOffendingIE(offendingie))
 		return msg.NewResponse(res)
diff --git a/pfcp/pdr_map.go b/pfcp/pdr_map.go
@@ -215,7 +215,7 @@ func (m *PDRMap) SimulateRemove(key api.PDRID) error {
 	return nil
 }
 
-func NewPDRMap(pdrs []*ie.IE) (pdrmap *PDRMap, err error, cause uint8, offendingIE uint16) {
+func NewPDRMap(pdrs []*ie.IE) (pdrmap *PDRMap, cause uint8, offendingIE uint16, err error) {
 	p := PDRMap{
 		pdrmap:    make(pdrmapInternal),
 		mu:        sync.RWMutex{},
@@ -229,44 +229,44 @@ func NewPDRMap(pdrs []*ie.IE) (pdrmap *PDRMap, err error, cause uint8, offending
 		if err != nil {
 			switch err {
 			case io.ErrUnexpectedEOF:
-				return nil, err, ie.CauseInvalidLength, ie.PDRID
+				return nil, ie.CauseInvalidLength, ie.PDRID, err
 			case ie.ErrIENotFound:
-				return nil, err, ie.CauseMandatoryIEMissing, ie.PDRID
+				return nil, ie.CauseMandatoryIEMissing, ie.PDRID, err
 			default:
-				return nil, err, ie.CauseMandatoryIEIncorrect, ie.CreatePDR
+				return nil, ie.CauseMandatoryIEIncorrect, ie.CreatePDR, err
 			}
 		}
 		pdi, err := pdr.PDI()
 		if err != nil {
 			switch err {
 			case io.ErrUnexpectedEOF:
-				return nil, err, ie.CauseInvalidLength, ie.PDI
+				return nil, ie.CauseInvalidLength, ie.PDI, err
 			case ie.ErrIENotFound:
-				return nil, err, ie.CauseMandatoryIEMissing, ie.PDI
+				return nil, ie.CauseMandatoryIEMissing, ie.PDI, err
 			default:
-				return nil, err, ie.CauseMandatoryIEIncorrect, ie.CreatePDR
+				return nil, ie.CauseMandatoryIEIncorrect, ie.CreatePDR, err
 			}
 		}
 		precedence, err := pdr.Precedence()
 		if err != nil {
 			switch err {
 			case io.ErrUnexpectedEOF:
-				return nil, err, ie.CauseInvalidLength, ie.Precedence
+				return nil, ie.CauseInvalidLength, ie.Precedence, err
 			case ie.ErrIENotFound:
-				return nil, err, ie.CauseMandatoryIEMissing, ie.Precedence
+				return nil, ie.CauseMandatoryIEMissing, ie.Precedence, err
 			default:
-				return nil, err, ie.CauseMandatoryIEIncorrect, ie.CreatePDR
+				return nil, ie.CauseMandatoryIEIncorrect, ie.CreatePDR, err
 			}
 		}
 		farid, err := pdr.FARID()
 		if err != nil {
 			switch err {
 			case io.ErrUnexpectedEOF:
-				return nil, err, ie.CauseInvalidLength, ie.FARID
+				return nil, ie.CauseInvalidLength, ie.FARID, err
 			case ie.ErrIENotFound:
-				return nil, err, ie.CauseMandatoryIEMissing, ie.FARID
+				return nil, ie.CauseMandatoryIEMissing, ie.FARID, err
 			default:
-				return nil, err, ie.CauseMandatoryIEIncorrect, ie.CreatePDR
+				return nil, ie.CauseMandatoryIEIncorrect, ie.CreatePDR, err
 			}
 		}
 
@@ -280,7 +280,7 @@ func NewPDRMap(pdrs []*ie.IE) (pdrmap *PDRMap, err error, cause uint8, offending
 			}
 			ohrIE = ie.NewOuterHeaderRemoval(ohr[0], ohr[1])
 		} else if err == io.ErrUnexpectedEOF {
-			return nil, err, ie.CauseInvalidLength, ie.OuterHeaderRemoval
+			return nil, ie.CauseInvalidLength, ie.OuterHeaderRemoval, err
 		}
 
 		err = p.Add(NewPDR(
@@ -291,10 +291,10 @@ func NewPDRMap(pdrs []*ie.IE) (pdrmap *PDRMap, err error, cause uint8, offending
 			ohrIE,
 		))
 		if err != nil {
-			return nil, err, ie.CauseMandatoryIEIncorrect, ie.CreatePDR
+			return nil, ie.CauseMandatoryIEIncorrect, ie.CreatePDR, err
 		}
 	}
-	return &p, nil, 0, 0
+	return &p, 0, 0, nil
 }
 
 func (m *PDRMap) IntoCreatePDR() []*ie.IE {
diff --git a/pfcp/peer.go b/pfcp/peer.go

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,8 @@`
`6`	`6`	`package api`
`7`	`7`
`8`	`8`	`import (`
	`9`	`+ "context"`
	`10`	`+`
`9`	`11`	`"github.com/wmnsk/go-pfcp/ie"`
`10`	`12`	`"github.com/wmnsk/go-pfcp/message"`
`11`	`13`	`)`
`@@ -19,5 +21,5 @@ type PFCPPeerInterface interface {`
`19`	`21`	`IsUserPlane() bool`
`20`	`22`	`IsControlPlane() bool`
`21`	`23`	`LocalEntity() PFCPEntityInterface`
`22`		`- NewEstablishedPFCPAssociation() (PFCPAssociationInterface, error)`
	`24`	`+ NewEstablishedPFCPAssociation(ctx context.Context) (PFCPAssociationInterface, error)`
`23`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -184,7 +184,7 @@ func (e *PFCPEntity) GetPFCPAssociation(nid string) (association api.PFCPAssocia`
`184`	`184`	`return e.associationsMap.Get(nid)`
`185`	`185`	`}`
`186`	`186`
`187`		`-func (e PFCPEntity) NewEstablishedPFCPAssociation(nodeID ie.IE) (association api.PFCPAssociationInterface, err error) {`
	`187`	`+func (e PFCPEntity) NewEstablishedPFCPAssociation(ctx context.Context, nodeID ie.IE) (association api.PFCPAssociationInterface, err error) {`
`188`	`188`	`peer, err := newPFCPPeerUP(e, nodeID)`
`189`	`189`	`if err != nil {`
`190`	`190`	`return nil, err`
`@@ -199,7 +199,7 @@ func (e PFCPEntity) NewEstablishedPFCPAssociation(nodeID ie.IE) (association a`
`199`	`199`	`if !e.associationsMap.CheckNonExist(nid) {`
`200`	`200`	`return nil, fmt.Errorf("association already exists")`
`201`	`201`	`}`
`202`		`- a, err := peer.NewEstablishedPFCPAssociation()`
	`202`	`+ a, err := peer.NewEstablishedPFCPAssociation(ctx)`
`203`	`203`	`if err != nil {`
`204`	`204`	`return nil, err`
`205`	`205`	`}`
Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ func (m FARMap) NewCreateFARs() []ie.IE {`
`129`	`129`	`return f`
`130`	`130`	`}`
`131`	`131`
`132`		`-func NewFARMap(fars []ie.IE) (farmap FARMap, err error, cause uint8, offendingIE uint16) {`
	`132`	`+func NewFARMap(fars []ie.IE) (farmap FARMap, cause uint8, offendingIE uint16, err error) {`
`133`	`133`	`f := FARMap{`
`134`	`134`	`farmap: make(farmapInternal),`
`135`	`135`	`mu: sync.RWMutex{},`
`@@ -139,22 +139,22 @@ func NewFARMap(fars []ie.IE) (farmap FARMap, err error, cause uint8, offending`
`139`	`139`	`if err != nil {`
`140`	`140`	`switch err {`
`141`	`141`	`case io.ErrUnexpectedEOF:`
`142`		`- return nil, err, ie.CauseInvalidLength, ie.FARID`
	`142`	`+ return nil, ie.CauseInvalidLength, ie.FARID, err`
`143`	`143`	`case ie.ErrIENotFound:`
`144`		`- return nil, err, ie.CauseMandatoryIEMissing, ie.FARID`
	`144`	`+ return nil, ie.CauseMandatoryIEMissing, ie.FARID, err`
`145`	`145`	`default:`
`146`		`- return nil, err, ie.CauseMandatoryIEIncorrect, ie.CreateFAR`
	`146`	`+ return nil, ie.CauseMandatoryIEIncorrect, ie.CreateFAR, err`
`147`	`147`	`}`
`148`	`148`	`}`
`149`	`149`	`aa, err := far.ApplyAction()`
`150`	`150`	`if err != nil {`
`151`	`151`	`switch err {`
`152`	`152`	`case io.ErrUnexpectedEOF:`
`153`		`- return nil, err, ie.CauseInvalidLength, ie.ApplyAction`
	`153`	`+ return nil, ie.CauseInvalidLength, ie.ApplyAction, err`
`154`	`154`	`case ie.ErrIENotFound:`
`155`		`- return nil, err, ie.CauseMandatoryIEMissing, ie.ApplyAction`
	`155`	`+ return nil, ie.CauseMandatoryIEMissing, ie.ApplyAction, err`
`156`	`156`	`default:`
`157`		`- return nil, err, ie.CauseMandatoryIEIncorrect, ie.CreateFAR`
	`157`	`+ return nil, ie.CauseMandatoryIEIncorrect, ie.CreateFAR, err`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`
`@@ -170,7 +170,7 @@ func NewFARMap(fars []ie.IE) (farmap FARMap, err error, cause uint8, offending`
`170`	`170`	`hasFP = true`
`171`	`171`	`}`
`172`	`172`	`if mustHaveFP && !hasFP {`
`173`		`- return nil, err, ie.CauseMandatoryIEIncorrect, ie.CreateFAR`
	`173`	`+ return nil, ie.CauseMandatoryIEIncorrect, ie.CreateFAR, err`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`if !hasFP {`
`@@ -179,10 +179,10 @@ func NewFARMap(fars []ie.IE) (farmap FARMap, err error, cause uint8, offending`
`179`	`179`	`err = f.Add(NewFAR(ie.NewFARID(id), ie.NewApplyAction(aa...), ie.NewForwardingParameters(fp...)))`
`180`	`180`	`}`
`181`	`181`	`if err != nil {`
`182`		`- return nil, err, ie.CauseMandatoryIEIncorrect, ie.CreateFAR`
	`182`	`+ return nil, ie.CauseMandatoryIEIncorrect, ie.CreateFAR, err`
`183`	`183`	`}`
`184`	`184`	`}`
`185`		`- return &f, nil, 0, 0`
	`185`	`+ return &f, 0, 0, nil`
`186`	`186`
`187`	`187`	`}`
`188`	`188`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ type FARMapUpdate struct {`
`22`	`22`	`mu sync.RWMutex`
`23`	`23`	`}`
`24`	`24`
`25`		`-func NewFARMapUpdate(fars []ie.IE) (FARMapUpdate, error, uint8, uint16) {`
	`25`	`+func NewFARMapUpdate(fars []ie.IE) (FARMapUpdate, uint8, uint16, error) {`
`26`	`26`	`f := FARMapUpdate{`
`27`	`27`	`farmap: make(farmapUpdateInternal),`
`28`	`28`	`mu: sync.RWMutex{},`
`@@ -32,11 +32,11 @@ func NewFARMapUpdate(fars []ie.IE) (FARMapUpdate, error, uint8, uint16) {`
`32`	`32`	`if err != nil {`
`33`	`33`	`switch err {`
`34`	`34`	`case io.ErrUnexpectedEOF:`
`35`		`- return nil, err, ie.CauseInvalidLength, ie.FARID`
	`35`	`+ return nil, ie.CauseInvalidLength, ie.FARID, err`
`36`	`36`	`case ie.ErrIENotFound:`
`37`		`- return nil, err, ie.CauseMandatoryIEMissing, ie.FARID`
	`37`	`+ return nil, ie.CauseMandatoryIEMissing, ie.FARID, err`
`38`	`38`	`default:`
`39`		`- return nil, err, ie.CauseMandatoryIEIncorrect, ie.CreateFAR`
	`39`	`+ return nil, ie.CauseMandatoryIEIncorrect, ie.CreateFAR, err`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`	`var ieaa *ie.IE = nil`
`@@ -51,7 +51,7 @@ func NewFARMapUpdate(fars []ie.IE) (FARMapUpdate, error, uint8, uint16) {`
`51`	`51`	`}`
`52`	`52`	`f.Add(NewFARUpdate(ie.NewFARID(id), ieaa, iefp))`
`53`	`53`	`}`
`54`		`- return &f, nil, 0, 0`
	`54`	`+ return &f, 0, 0, nil`
`55`	`55`
`56`	`56`	`}`
`57`	`57`