feat: add protocol multiplexing support for OCPP 1.6 and 2.0.1

Enable running both OCPP 1.6 and OCPP 2.0.1 servers on a single WebSocket
port using subprotocol-based message routing.

Changes:
- ws.Server: Add SetMessageHandlerForSubprotocol for per-subprotocol routing
- ws.Server: Make Start() idempotent for shared server instances
- ocppj.Server: Add SetSubprotocol to register protocol-specific handlers
- ocpp1.6/ocpp2.0.1: Auto-set subprotocol in constructors
- New multiplex package with MultiProtocolServer for unified API

Fixes #417

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: andig

example/multiplex/main.go

@@ -0,0 +1,105 @@
+// Example demonstrating protocol multiplexing for OCPP 1.6 and 2.0.1 on a single port.
+//
+// This server can handle both OCPP 1.6 charge points and OCPP 2.0.1 charging stations
+// simultaneously using WebSocket subprotocol negotiation.
+//
+// When a client connects with "Sec-WebSocket-Protocol: ocpp2.0.1, ocpp1.6",
+// the server negotiates the first mutually-supported protocol.
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/lorenzodonini/ocpp-go/multiplex"
+	"github.com/lorenzodonini/ocpp-go/ocpp1.6/core"
+	"github.com/lorenzodonini/ocpp-go/ocpp1.6/types"
+	"github.com/lorenzodonini/ocpp-go/ocpp2.0.1/provisioning"
+	types2 "github.com/lorenzodonini/ocpp-go/ocpp2.0.1/types"
+	"github.com/lorenzodonini/ocpp-go/ws"
+)
+
+// OCPP 1.6 handler
+type ocpp16Handler struct{}
+
+func (h *ocpp16Handler) OnAuthorize(chargePointId string, request *core.AuthorizeRequest) (*core.AuthorizeConfirmation, error) {
+	fmt.Printf("[OCPP 1.6] Authorize from %s: %s\n", chargePointId, request.IdTag)
+	return core.NewAuthorizationConfirmation(types.NewIdTagInfo(types.AuthorizationStatusAccepted)), nil
+}
+
+func (h *ocpp16Handler) OnBootNotification(chargePointId string, request *core.BootNotificationRequest) (*core.BootNotificationConfirmation, error) {
+	fmt.Printf("[OCPP 1.6] BootNotification from %s: %s %s\n", chargePointId, request.ChargePointVendor, request.ChargePointModel)
+	return core.NewBootNotificationConfirmation(types.NewDateTime(time.Now()), 60, core.RegistrationStatusAccepted), nil
+}
+
+func (h *ocpp16Handler) OnDataTransfer(chargePointId string, request *core.DataTransferRequest) (*core.DataTransferConfirmation, error) {
+	fmt.Printf("[OCPP 1.6] DataTransfer from %s\n", chargePointId)
+	return core.NewDataTransferConfirmation(core.DataTransferStatusAccepted), nil
+}
+
+func (h *ocpp16Handler) OnHeartbeat(chargePointId string, request *core.HeartbeatRequest) (*core.HeartbeatConfirmation, error) {
+	fmt.Printf("[OCPP 1.6] Heartbeat from %s\n", chargePointId)
+	return core.NewHeartbeatConfirmation(types.NewDateTime(time.Now())), nil
+}
+
+func (h *ocpp16Handler) OnMeterValues(chargePointId string, request *core.MeterValuesRequest) (*core.MeterValuesConfirmation, error) {
+	fmt.Printf("[OCPP 1.6] MeterValues from %s\n", chargePointId)
+	return core.NewMeterValuesConfirmation(), nil
+}
+
+func (h *ocpp16Handler) OnStartTransaction(chargePointId string, request *core.StartTransactionRequest) (*core.StartTransactionConfirmation, error) {
+	fmt.Printf("[OCPP 1.6] StartTransaction from %s\n", chargePointId)
+	return core.NewStartTransactionConfirmation(types.NewIdTagInfo(types.AuthorizationStatusAccepted), 1), nil
+}
+
+func (h *ocpp16Handler) OnStatusNotification(chargePointId string, request *core.StatusNotificationRequest) (*core.StatusNotificationConfirmation, error) {
+	fmt.Printf("[OCPP 1.6] StatusNotification from %s: connector %d is %s\n", chargePointId, request.ConnectorId, request.Status)
+	return core.NewStatusNotificationConfirmation(), nil
+}
+
+func (h *ocpp16Handler) OnStopTransaction(chargePointId string, request *core.StopTransactionRequest) (*core.StopTransactionConfirmation, error) {
+	fmt.Printf("[OCPP 1.6] StopTransaction from %s\n", chargePointId)
+	return core.NewStopTransactionConfirmation(), nil
+}
+
+// OCPP 2.0.1 handler
+type ocpp201Handler struct{}
+
+func (h *ocpp201Handler) OnBootNotification(chargingStationId string, request *provisioning.BootNotificationRequest) (*provisioning.BootNotificationResponse, error) {
+	fmt.Printf("[OCPP 2.0.1] BootNotification from %s: %s %s\n", chargingStationId, request.ChargingStation.VendorName, request.ChargingStation.Model)
+	return provisioning.NewBootNotificationResponse(types2.NewDateTime(time.Now()), 60, provisioning.RegistrationStatusAccepted), nil
+}
+
+func (h *ocpp201Handler) OnNotifyReport(chargingStationId string, request *provisioning.NotifyReportRequest) (*provisioning.NotifyReportResponse, error) {
+	fmt.Printf("[OCPP 2.0.1] NotifyReport from %s\n", chargingStationId)
+	return provisioning.NewNotifyReportResponse(), nil
+}
+
+func main() {
+	// Create multi-protocol server
+	server := multiplex.NewMultiProtocolServer()
+
+	// Register OCPP 1.6 handlers
+	server.OCPP16Server().SetCoreHandler(&ocpp16Handler{})
+
+	// Register OCPP 2.0.1 handlers
+	server.OCPP201Server().SetProvisioningHandler(&ocpp201Handler{})
+
+	// Track connections and their protocol versions
+	server.SetNewClientHandler(func(channel ws.Channel) {
+		fmt.Printf("New client connected: %s (protocol: %s)\n", channel.ID(), channel.Subprotocol())
+	})
+
+	server.SetDisconnectedClientHandler(func(channel ws.Channel) {
+		fmt.Printf("Client disconnected: %s\n", channel.ID())
+	})
+
+	// Start listening on port 8080
+	fmt.Println("Starting multi-protocol OCPP server on :8080/ocpp/{id}")
+	fmt.Println("Supported protocols: ocpp1.6, ocpp2.0.1")
+	fmt.Println()
+	fmt.Println("Clients can connect with either protocol. The server will negotiate")
+	fmt.Println("based on the Sec-WebSocket-Protocol header.")
+
+	server.Start(8080, "/ocpp/{id}")
+}

multiplex/multiplex.go

@@ -0,0 +1,101 @@
+// Package multiplex provides protocol multiplexing support for OCPP servers.
+// It allows a single WebSocket server to handle both OCPP 1.6 and OCPP 2.0.1 clients
+// on the same port, using WebSocket subprotocol negotiation to route connections
+// to the appropriate handler.
+package multiplex
+
+import (
+	ocpp16 "github.com/lorenzodonini/ocpp-go/ocpp1.6"
+	ocpp2 "github.com/lorenzodonini/ocpp-go/ocpp2.0.1"
+	"github.com/lorenzodonini/ocpp-go/ws"
+)
+
+// ProtocolVersion represents an OCPP protocol version.
+type ProtocolVersion string
+
+const (
+	// V16 represents OCPP 1.6
+	V16 ProtocolVersion = "ocpp1.6"
+	// V201 represents OCPP 2.0.1
+	V201 ProtocolVersion = "ocpp2.0.1"
+)
+
+// Subprotocol constants for WebSocket negotiation.
+const (
+	V16Subprotocol  = "ocpp1.6"
+	V201Subprotocol = "ocpp2.0.1"
+)
+
+// SubprotocolSelector is a callback function that allows the application to choose
+// which subprotocol to use when a client requests multiple subprotocols.
+//
+// Parameters:
+//   - clientID: The identifier of the connecting client (extracted from the URL path)
+//   - requestedSubprotocols: The list of subprotocols requested by the client
+//     (from the Sec-WebSocket-Protocol header, e.g., ["ocpp2.0.1", "ocpp1.6"])
+//
+// Returns the subprotocol to use for this connection (e.g., "ocpp1.6" or "ocpp2.0.1").
+// The returned value must be one of the supported subprotocols.
+// If an empty string is returned, the default behavior is used (first mutually-supported protocol).
+//
+// Example:
+//
+//	server.SetSubprotocolSelector(func(clientID string, requested []string) string {
+//	    // Always prefer OCPP 2.0.1 if the client supports it
+//	    for _, p := range requested {
+//	        if p == multiplex.V201Subprotocol {
+//	            return p
+//	        }
+//	    }
+//	    // Fall back to first requested
+//	    if len(requested) > 0 {
+//	        return requested[0]
+//	    }
+//	    return ""
+//	})
+type SubprotocolSelector func(clientID string, requestedSubprotocols []string) string
+
+// MultiProtocolServer is a server that can handle both OCPP 1.6 and OCPP 2.0.1 clients
+// on a single port. It uses WebSocket subprotocol negotiation to determine which
+// protocol version each client uses.
+type MultiProtocolServer interface {
+	// Start begins listening for connections on the specified port and path.
+	// The function blocks until Stop is called.
+	//
+	// Example:
+	//   go server.Start(8080, "/ocpp/{id}")
+	Start(port int, listenPath string)
+
+	// Stop gracefully shuts down the server.
+	Stop()
+
+	// OCPP16Server returns the underlying OCPP 1.6 Central System.
+	// Use this to register handlers for OCPP 1.6 messages.
+	OCPP16Server() ocpp16.CentralSystem
+
+	// OCPP201Server returns the underlying OCPP 2.0.1 CSMS.
+	// Use this to register handlers for OCPP 2.0.1 messages.
+	OCPP201Server() ocpp2.CSMS
+
+	// SetSubprotocolSelector sets a custom callback for choosing which subprotocol
+	// to use when a client requests multiple subprotocols. This allows the application
+	// to implement custom protocol selection logic (e.g., prefer OCPP 2.0.1 over 1.6).
+	// If not set, the default behavior is used (first mutually-supported protocol).
+	SetSubprotocolSelector(selector SubprotocolSelector)
+
+	// SetNewClientHandler sets a callback for all new client connections,
+	// regardless of protocol version. The callback receives the WebSocket channel
+	// which can be used to determine the protocol via channel.Subprotocol().
+	SetNewClientHandler(handler func(channel ws.Channel))
+
+	// SetDisconnectedClientHandler sets a callback for all client disconnections,
+	// regardless of protocol version.
+	SetDisconnectedClientHandler(handler func(channel ws.Channel))
+
+	// SetBasicAuthHandler enables HTTP Basic Authentication for all connections.
+	SetBasicAuthHandler(handler func(username, password string) bool)
+
+	// SetCheckClientHandler sets a validation handler for incoming connections.
+	// Return false to reject the connection.
+	SetCheckClientHandler(handler ws.CheckClientHandler)
+}