How can I send signal from the server to the client upon receiving os.Interrupt

In my code, I've the below that is listening to os.Interrupt before closing

package main

import (
	"net/http"
	"os"
	"os/signal"
	"syscall"
)

var passer *DataPasser

const maxClients = 1

func init() {
	passer = &DataPasser{
		data:       make(chan sseData),
		logs:       make(chan string),
		connection: make(chan struct{}, maxClients),
	}
}

func main() {

	http.HandleFunc("/sse", passer.HandleSignal)
	go http.ListenAndServe(":1234", nil)

	// Listen to Ctrl+C (you can also do something else that prevents the program from exiting)
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt, syscall.SIGTERM)

	<-c
	if client.IsConnected() {
		client.Disconnect()
	}
}

The passer.HandleSignal is a function that is sending SSE Server Sent Event to the client, as:

package main

import (
	"fmt"
	"net/http"
)

type sseData struct {
	event, message string
}
type DataPasser struct {
	data       chan sseData
	connection chan struct{} // To control maximum allowed clients connections
}

func (p *DataPasser) HandleSignal(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/event-stream; charset=utf-8")
	w.Header().Set("Cache-Control", "no-cache")
	w.Header().Set("Connection", "keep-alive")

	fmt.Println("Client connected from IP:", r.RemoteAddr)

	p.connection <- struct{}{}
	flusher, ok := w.(http.Flusher)
	if !ok {
		http.Error(w, "Internal error", 500)
		return
	}

	fmt.Fprint(w, "event: notification\ndata: Connection to WhatsApp server ...\n\n")
	flusher.Flush()

	// Connect to the WhatsApp client
	go Connect()

	for {
		select {
		case data := <-p.data:
			fmt.Println("recieved")

			switch {
			case len(data.event) > 0:
				fmt.Fprintf(w, "event: %v\ndata: %v\n\n", data.event, data.message)
			case len(data.event) == 0:
				fmt.Fprintf(w, "data: %v\n\n", data.message)
			}
			flusher.Flush()
		case <-r.Context().Done():
			<-p.connection
			fmt.Println("Connection closed")
			return
		}
	}
}

func Connect() {
   // Doing data manipulation, and sending reselt to the `parser`
   passer.data <- sseData{
			event:   "notification",
			message: "Reconnecting to WhatsApp server ...",
   }
}

My question is that, if the user interupted the application using Ctrl+C, the main function is responding to it, I need it to send data to the parser so that the handler send notification to the client that the server had been shut down

I found the solution, it was trivial, just pass date to the parser which is defined as global variable within the os.interupt scope, as:

	<-c
	if client.IsConnected() {
		passer.data <- sseData{
			event:   "notification",
			message: "Server is shut down at the host machine...",
		}
		client.Disconnect()
	}