func (self *AuthElement) Handle(st stream.ServerStream, opts features.Options) error {
mechs := map[string]Handler{} // create this on stack - no garbage
for _, mech := range opts.(AuthConfig) {
if handler, ok := mechanism_handlers[mech]; ok {
mechs[mech] = handler
}
}
if handler := mechs[self.Mechanism]; handler != nil {
if err := handler(self, st); err != nil {
log.Println("Authorization failed:", err)
if err := st.WriteElement(NewFailute(NotAuthorized{})); err != nil {
return err
}
return err
}
} else {
if err := st.WriteElement(NewFailute(InvalidMechanism{})); err != nil {
return err
}
return fmt.Errorf("No handler for mechanism %v", self.Mechanism)
}
return nil
}
func (fw *Feature) Handle(strm stream.ServerStream, opts Options) error {
if opts == nil {
opts = fw.config
}
if err := fw.handlerElement.Handle(strm, opts); err != nil {
return err
}
EnableStreamFeatures(strm, fw.name)
strm.RemoveFeature(fw.name)
return nil
}
func (s *StartTLSElement) Handle(st stream.ServerStream, opts features.Options) error {
conf := opts.(*startTLSConf)
cert, err := tls.LoadX509KeyPair(conf.PEMPath, conf.KeyPath)
if err != nil {
log.Println("Could not load keys:", err)
return err
}
config := &tls.Config{
Certificates: []tls.Certificate{cert},
ClientAuth: tls.VerifyClientCertIfGiven,
Rand: rand.Reader,
}
err = st.UpdateRW(func(srwc io.ReadWriteCloser) (io.ReadWriteCloser, error) {
if conn, ok := srwc.(net.Conn); ok {
tls_conn := tls.Server(conn, config)
// Once we inialized - let client proceed
if err := st.WriteElement(&ProceedElement{}); err != nil {
return nil, err
}
// Now do a handshake
if err := tls_conn.Handshake(); err != nil {
log.Println("TLS Handshake error:", err)
return nil, err
}
return tls_conn, nil
}
return nil, errors.New("Wrong ReadWriteCloser, expected connection")
})
if err != nil {
log.Println("Could not replace connection", err)
return err
}
state := NewStartTLSState()
state.Started = true
st.State().Push(state)
st.ReOpen()
return nil
}
func EnableStreamFeatures(s stream.ServerStream, name string) {
for _, fname := range s.DependencyGraph().Get(name) {
fe := FeatureFactory.Get(fname)
conf, err := fe.GetConfig(s.Config()[fname])
if err != nil {
log.Printf("goxmpp: unable to handle config for feature %s: %s", fname, err)
continue
}
feature := fe.Constructor(conf)
s.AddNamed(
func() xtream.Element { return feature.InitHandler() },
fe.Parent,
fe.Name,
)
s.AddFeature(feature)
}
}
func (self *SessionElement) Handle(strm stream.ServerStream, opts features.Options) error {
request_id := opts.(*iq.IQElement)
// FIXME(goxmpp): 2014-04-04: auth check, state presence check, resource check required
var state *SessionState
if err := strm.State().Get(&state); err != nil {
state = &SessionState{}
strm.State().Push(state)
}
state.Active = true
log.Printf("Session opened")
// TODO(goxmpp): 2014-04-03: might be easier to just use original IQ?
response_iq := iq.NewIQElement()
response_iq.Type = "result"
response_iq.ID = request_id.ID
if err := strm.WriteElement(response_iq); err != nil {
return err
}
return nil
}
func (self *BindElement) Handle(strm stream.ServerStream, opts features.Options) error {
request_id := opts.(*iq.IQElement)
// FIXME(goxmpp): 2014-04-03: auth check, state presence check, resource check required
var state *BindState
strm.State().Get(&state)
if state.VerifyResource(self.Resource) {
state.Resource = self.Resource
} else {
// TODO(goxmpp): 2014-04-03
}
var authState *auth.AuthState
strm.State().Get(&authState)
strm.SetClientJID(authState.UserName + "@" + strm.ServerName() + "/" + state.Resource)
log.Printf("Bound to JID: %#v", strm.ClientJID())
// TODO(goxmpp): 2014-04-03: might be easier to just use original IQ?
response_iq := iq.NewIQElement()
response_iq.Type = "result"
response_iq.ID = request_id.ID
response_iq.AddElement(&BindElement{JID: strm.ClientJID()})
if err := strm.WriteElement(response_iq); err != nil {
return err
}
return nil
}
func (c *compressElement) Handle(s stream.ServerStream, opts features.Options) error {
var compressor Compressor
conf := opts.(CompressionConfig)
if _, ok := conf[c.Method]; ok {
if compr, ok := Methods[c.Method]; ok {
compressor = compr
}
}
if compressor == nil {
if err := s.WriteElement(&MethodNotSupportedError{}); err != nil {
return err
}
return fmt.Errorf("Unsupported compression method requested")
}
var state *CompressState
if err := s.State().Get(&state); err != nil {
state = NewCompressState()
s.State().Push(state)
}
state.Compressed = true
if err := s.WriteElement(&CompressionSuccess{}); err != nil {
return err
}
if err := swapStreamRW(s, compressor); err != nil {
if err := s.WriteElement(&ProcessingFailedError{}); err != nil {
return err
}
return err
}
s.ReOpen()
return nil
}
