Package Config/component/LDAP:

- replace mutex by atomic
- fix minor bugs & optimize code

Package Size:
- add function 'mul' allowing do a multiplaction on the size value by a float64 given value (could use another size.float64)
- add function 'div' allowing do a division of the size value by a float64 given value (could use another size.float64)
- add function 'add' allowing do an addtion of the size value with a uint64 given value (could use another size.uint64)
- add function 'sub' allowing do an substraction of the size value with a uint64 given value (could use another size.uint64)

Package Encoding:
- rework completly crypt package to new package encoding
- part aes of old crypt become new subpackage encoding/aes
- part hex of old crypt (associated with aes) become new standalone subpackage encoding/hexa
- adding new subpackage mux to use multiplexer/de-multiplexer of io stream
- mux is different of multireader / multiwriter in way as io send from mux in one channel will be received only in the coresponding channel  of de-mux
- mux is encoding subpackage becauxse based on hex + cbor marshalling / unmarshalling
- all subpackage can be used directly of by io reader / writer

Package Socket/server
- rework server to use as possible direct io to con
- rework server to optimize & fix managment (context / shutdown...)
- rework server to stop connection befor stopping server
- rework server to not load incoming and send it to handler by allowing handler to manager io input/output directly
- server not more used buff internally (less memory consuption)
- adding counter of opened connection
- adding some testing who's checking server & client for each protocol

Package Socket/client
- rework client to allow connect to server before reading/writing on io stream
- rework client to allow consum direct io stream instead of reading locally / call function
- rework client to allow having less memory consumption by removing internal buffer
- rework client allowing to use root io function (bufio, io copy, ...)

Package Socket/multi
- adding new subpackage multi to simplfy using of 1 reader / x writer
- if no writer is define, using an extended io discard
- allowing asynch instancing, populate writer and calling main writer
- allowing calling writer / reader to expose the main io reader / writer

Package Socket/delim:
- adding new subpackage delim to simplify using of bufio reader with delimiter
- using 1 writer / 1 reader
- allowing root io function like readwritecloser, writeto, ...
- use local buffer to prevent race if reader and writer are not is same process

Package PProf:
- fix missing \n in message

Package HttpServer:
- fix bug with init TLS & http2

Other:
- bump dependencies

socket/server/udp/model.go

@@ -48,61 +48,76 @@ func init() {
 }
 
 type srv struct {
-	l net.Listener
-
-	h *atomic.Value // handler
-	c *atomic.Value // chan []byte
-	s *atomic.Value // chan struct{}
-	r *atomic.Bool  // is Running
+	hdl *atomic.Value // handler
+	msg *atomic.Value // chan []byte
+	stp *atomic.Value // chan struct{}
+	run *atomic.Bool  // is Running
 
 	fe *atomic.Value // function error
 	fi *atomic.Value // function info
 	fs *atomic.Value // function info server
 
-	sr *atomic.Int32 // read buffer size
 	ad *atomic.Value // Server address url
 }
 
+func (o *srv) OpenConnections() int64 {
+	if o.IsRunning() {
+		return 1
+	}
+
+	return 0
+}
+
 func (o *srv) IsRunning() bool {
-	return o.r.Load()
+	return o.run.Load()
+}
+
+func (o *srv) IsGone() bool {
+	return !o.IsRunning()
 }
 
 func (o *srv) Done() <-chan struct{} {
-	s := o.s.Load()
-	if s != nil {
-		return s.(chan struct{})
+	if o == nil {
+		return closedChanStruct
+	}
+
+	if i := o.stp.Load(); i != nil {
+		if c, k := i.(chan struct{}); k {
+			return c
+		}
 	}
 
 	return closedChanStruct
 }
 
-func (o *srv) Close() error {
-	return o.Shutdown()
+func (o *srv) Gone() <-chan struct{} {
+	return closedChanStruct
 }
 
-func (o *srv) Shutdown() error {
+func (o *srv) Close() error {
+	return o.Shutdown(context.Background())
+}
+
+func (o *srv) StopListen(ctx context.Context) error {
 	if o == nil {
 		return ErrInvalidInstance
 	}
 
-	s := o.s.Load()
-	if s != nil {
-		if c, k := s.(chan struct{}); k {
-			c <- struct{}{}
-			o.s.Store(c)
+	if i := o.stp.Load(); i != nil {
+		if c, k := i.(chan struct{}); k && c != closedChanStruct {
+			close(c)
 		}
 	}
+	o.stp.Store(closedChanStruct)
 
 	var (
-		tck      = time.NewTicker(100 * time.Millisecond)
-		ctx, cnl = context.WithTimeout(context.Background(), 25*time.Second)
+		tck = time.NewTicker(5 * time.Millisecond)
+		cnl context.CancelFunc
 	)
 
-	defer func() {
-		if s != nil {
-			o.s.Store(closedChanStruct)
-		}
+	ctx, cnl = context.WithTimeout(ctx, 10*time.Second)
 
+	defer func() {
 		tck.Stop()
 		cnl()
 	}()
@@ -118,6 +133,18 @@ func (o *srv) Shutdown() error {
 			return nil
 		}
 	}
+
+}
+
+func (o *srv) Shutdown(ctx context.Context) error {
+	if o == nil {
+		return ErrInvalidInstance
+	}
+
+	var cnl context.CancelFunc
+	ctx, cnl = context.WithTimeout(ctx, 25*time.Second)
+	defer cnl()
+	return o.StopListen(ctx)
 }
 
 func (o *srv) SetTLS(enable bool, config libtls.TLSConfig) error {
@@ -197,7 +224,7 @@ func (o *srv) handler() libsck.Handler {
 		return nil
 	}
 
-	v := o.h.Load()
+	v := o.hdl.Load()
 	if v != nil {
 		return v.(libsck.Handler)
 	}