func sendACR(c diam.Conn, cfg *sm.Settings, n int) {
// Get this client's metadata from the connection object,
// which is set by the state machine after the handshake.
// It contains the peer's Origin-Host and Realm from the
// CER/CEA handshake. We use it to populate the AVPs below.
meta, ok := smpeer.FromContext(c.Context())
if !ok {
log.Fatal("Client connection does not contain metadata")
}
var err error
var m *diam.Message
for i := 0; i < n; i++ {
m = diam.NewRequest(diam.Accounting, 0, c.Dictionary())
m.NewAVP(avp.SessionID, avp.Mbit, 0,
datatype.UTF8String(strconv.Itoa(i)))
m.NewAVP(avp.OriginHost, avp.Mbit, 0, cfg.OriginHost)
m.NewAVP(avp.OriginRealm, avp.Mbit, 0, cfg.OriginRealm)
m.NewAVP(avp.DestinationRealm, avp.Mbit, 0, meta.OriginRealm)
m.NewAVP(avp.AccountingRecordType, avp.Mbit, 0, eventRecord)
m.NewAVP(avp.AccountingRecordNumber, avp.Mbit, 0,
datatype.Unsigned32(i))
m.NewAVP(avp.DestinationHost, avp.Mbit, 0, meta.OriginHost)
if _, err = m.WriteTo(c); err != nil {
log.Fatal(err)
}
}
}
func TestHandleCER_HandshakeMetadata(t *testing.T) {
sm := New(serverSettings)
srv := diamtest.NewServer(sm, dict.Default)
defer srv.Close()
hsc := make(chan diam.Conn, 1)
cli, err := diam.Dial(srv.Address, nil, dict.Default)
if err != nil {
t.Fatal(err)
}
defer cli.Close()
ready := make(chan struct{})
go func() {
close(ready)
c := <-sm.HandshakeNotify()
hsc <- c
}()
<-ready
m := diam.NewRequest(diam.CapabilitiesExchange, 1001, dict.Default)
m.NewAVP(avp.OriginHost, avp.Mbit, 0, clientSettings.OriginHost)
m.NewAVP(avp.OriginRealm, avp.Mbit, 0, clientSettings.OriginRealm)
m.NewAVP(avp.HostIPAddress, avp.Mbit, 0, localhostAddress)
m.NewAVP(avp.VendorID, avp.Mbit, 0, clientSettings.VendorID)
m.NewAVP(avp.ProductName, 0, 0, clientSettings.ProductName)
m.NewAVP(avp.OriginStateID, avp.Mbit, 0, datatype.Unsigned32(1))
m.NewAVP(avp.AcctApplicationID, avp.Mbit, 0, datatype.Unsigned32(1001))
m.NewAVP(avp.FirmwareRevision, avp.Mbit, 0, clientSettings.FirmwareRevision)
_, err = m.WriteTo(cli)
if err != nil {
t.Fatal(err)
}
select {
case c := <-hsc:
ctx := c.Context()
meta, ok := smpeer.FromContext(ctx)
if !ok {
t.Fatal("Handshake ok but no context/metadata found")
}
if meta.OriginHost != clientSettings.OriginHost {
t.Fatalf("Unexpected OriginHost. Want %q, have %q",
clientSettings.OriginHost, meta.OriginHost)
}
if meta.OriginRealm != clientSettings.OriginRealm {
t.Fatalf("Unexpected OriginRealm. Want %q, have %q",
clientSettings.OriginRealm, meta.OriginRealm)
}
}
}
// handleCER handles Capabilities-Exchange-Request messages.
//
// If mandatory AVPs such as Origin-Host or Origin-Realm
// are missing, we close the connection.
//
// See RFC 6733 section 5.3 for details.
func handleCER(sm *StateMachine) diam.HandlerFunc {
return func(c diam.Conn, m *diam.Message) {
ctx := c.Context()
if _, ok := smpeer.FromContext(ctx); ok {
// Ignore retransmission.
return
}
cer := new(smparser.CER)
failedAVP, err := cer.Parse(m)
if err != nil {
if failedAVP != nil {
err = errorCEA(sm, c, m, cer, failedAVP)
if err != nil {
sm.Error(&diam.ErrorReport{
Conn: c,
Message: m,
Error: err,
})
}
}
c.Close()
return
}
err = successCEA(sm, c, m, cer)
if err != nil {
sm.Error(&diam.ErrorReport{
Conn: c,
Message: m,
Error: err,
})
return
}
meta := smpeer.FromCER(cer)
c.SetContext(smpeer.NewContext(ctx, meta))
// Notify about peer passing the handshake.
select {
case sm.hsNotifyc <- c:
default:
}
}
}
func sendHMR(c diam.Conn, cfg *sm.Settings) error {
// Get this client's metadata from the connection object,
// which is set by the state machine after the handshake.
// It contains the peer's Origin-Host and Realm from the
// CER/CEA handshake. We use it to populate the AVPs below.
meta, ok := smpeer.FromContext(c.Context())
if !ok {
return errors.New("peer metadata unavailable")
}
sid := "session;" + strconv.Itoa(int(rand.Uint32()))
m := diam.NewRequest(helloMessage, helloApplication, nil)
m.NewAVP(avp.SessionID, avp.Mbit, 0, datatype.UTF8String(sid))
m.NewAVP(avp.OriginHost, avp.Mbit, 0, cfg.OriginHost)
m.NewAVP(avp.OriginRealm, avp.Mbit, 0, cfg.OriginRealm)
m.NewAVP(avp.DestinationRealm, avp.Mbit, 0, meta.OriginRealm)
m.NewAVP(avp.DestinationHost, avp.Mbit, 0, meta.OriginHost)
m.NewAVP(avp.UserName, avp.Mbit, 0, datatype.UTF8String("foobar"))
log.Printf("Sending HMR to %s\n%s", c.RemoteAddr(), m)
_, err := m.WriteTo(c)
return err
}
// ServeDIAM implements the diam.Handler interface.
func (f handshakeOK) ServeDIAM(c diam.Conn, m *diam.Message) {
if _, ok := smpeer.FromContext(c.Context()); ok {
f(c, m)
}
}