Merge pull request #7 from WeirdBob/master

Use IPC_INFO to get msgmax size (Linux support)

Author: siadat

cmd/ipcctl/main.go

@@ -90,6 +90,8 @@ func main() {
 		if err != nil {
 			log.Fatal(err)
 		}
+	default:
+		log.Fatalf("Unsupported option %s\n", os.Args[1])
 	}
 }
 

common.go

@@ -1,5 +1,9 @@
 package ipc
 
+import (
+	"math/bits"
+)
+
 const (
 	// https://code.woboq.org/userspace/glibc/sysdeps/unix/sysv/linux/bits/ipc.h.html
 	// Mode bits for `msgget', `semget', and `shmget'.
@@ -17,16 +21,14 @@ const (
 	IPC_PRIVATE = 0 // Private key. NOTE: this value is of type __key_t, i.e., ((__key_t) 0)
 )
 
-const (
-	bufSize = 8192
-)
+var msgmax = 8192  // default size, will be overriden during init to match system msgmax
+var uintSize = bits.UintSize / 8 // size of a uint, arch dependent
 
 type Msgbuf struct {
 	Mtype uint
 	Mtext []byte
 }
 
-type msgbufInternal struct {
-	Mtype uint
-	Mtext [bufSize]byte
-}
+func Msgmax() int {
+	return msgmax
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/siadat/ipc
+
+go 1.14

init_linux.go

@@ -0,0 +1,31 @@
+package ipc
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func init() {
+	var buf msginfo
+	_, _, err := syscall.Syscall(
+		syscall.SYS_MSGCTL, 
+		0, 
+		uintptr(IPC_INFO), 
+		uintptr(unsafe.Pointer(&buf)))
+	if err != 0 {
+		return // can't read current msg info, leave defaults
+	}
+
+	msgmax = int(buf.msgmax)
+}
+
+type msginfo struct {
+    msgpool int32
+    msgmap int32
+    msgmax int32
+    msgmnb int32
+    msgmni int32
+    msgssz int32
+    msgtql int32
+    msgseg uint16
+}

msgrcv.go

@@ -1,28 +1,45 @@
 package ipc
 
 import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
 	"syscall"
 	"unsafe"
 )
 
 // Msgrcv calls the msgrcv() syscall.
 func Msgrcv(qid uint, msg *Msgbuf, flags uint) error {
-	qbuf := msgbufInternal{
-		Mtype: msg.Mtype,
-	}
-	lengthRead, _, err := syscall.Syscall6(syscall.SYS_MSGRCV,
+	var buf = make([]byte, uintSize+msgmax)
+
+	lengthRead, _, errno := syscall.Syscall6(syscall.SYS_MSGRCV,
 		uintptr(qid),
-		uintptr(unsafe.Pointer(&qbuf)),
-		uintptr(bufSize),
+		uintptr(unsafe.Pointer(&buf[0])),
+		uintptr(msgmax),
 		uintptr(msg.Mtype),
 		uintptr(flags),
 		0,
 	)
-	if err != 0 {
-		return err
+	if errno != 0 {
+		return errno
 	}
-
-	msg.Mtype = qbuf.Mtype
-	msg.Mtext = qbuf.Mtext[:lengthRead]
+	buffer := bytes.NewBuffer(buf)
+	switch uintSize {
+	case 4:
+		var mtype uint32
+		err := binary.Write(buffer, binary.LittleEndian, &mtype)
+		if err != nil {
+			return fmt.Errorf("Can't write binary: %v", err)
+		}
+		msg.Mtype = uint(mtype)
+	case 8:
+		var mtype uint64
+		err := binary.Write(buffer, binary.LittleEndian, &mtype)
+		if err != nil {
+			return fmt.Errorf("Can't write binary: %v", err)
+		}
+		msg.Mtype = uint(mtype)
+	}
+	msg.Mtext = buf[uintSize:uintSize+int(lengthRead)]
 	return nil
 }

msgrcv_test.go

@@ -41,7 +41,7 @@ func TestMsgrcv(t *testing.T) {
 	if err != nil {
 		panic(fmt.Sprintf("Failed to send message to ipc id %d: %s\n", qid, err))
 	} else {
-		fmt.Printf("Message %v send to ipc id %d\n", input, qid)
+		fmt.Printf("Message %x send to ipc id %d\n", input, qid)
 	}
 
 	qbuf := &ipc.Msgbuf{Mtype: 12}
@@ -51,7 +51,7 @@ func TestMsgrcv(t *testing.T) {
 	if err != nil {
 		panic(fmt.Sprintf("Failed to receive message to ipc id %d: %s\n", qid, err))
 	} else {
-		fmt.Printf("Message %v receive to ipc id %d\n", qbuf.Mtext, qid)
+		fmt.Printf("Message %x receive to ipc id %d\n", qbuf.Mtext, qid)
 	}
 
 	if !bytes.Equal(input, qbuf.Mtext) {

msgsnd.go

@@ -1,31 +1,43 @@
 package ipc
 
 import (
+	"bytes"
+	"encoding/binary"
 	"fmt"
 	"syscall"
 	"unsafe"
 )
 
 // Msgsnd calls the msgsnd() syscall.
 func Msgsnd(qid uint, msg *Msgbuf, flags uint) error {
-	if len(msg.Mtext) > bufSize {
-		return fmt.Errorf("mtext is too large, %d > %d", len(msg.Mtext), bufSize)
+	if len(msg.Mtext) > msgmax {
+		return fmt.Errorf("mtext is too large, %d > %d", len(msg.Mtext), msgmax)
 	}
-	qbuf := msgbufInternal{
-		Mtype: msg.Mtype,
-	}
-	copy(qbuf.Mtext[:], msg.Mtext)
 
-	_, _, err := syscall.Syscall6(syscall.SYS_MSGSND,
+	buf := make([]byte, uintSize+msgmax)
+	buffer := bytes.NewBuffer(buf)
+	buffer.Reset()
+	var err error
+	switch uintSize {
+	case 4:
+		err = binary.Write(buffer, binary.LittleEndian, uint32(msg.Mtype))
+	case 8:
+		err = binary.Write(buffer, binary.LittleEndian, uint64(msg.Mtype))
+	}
+	if err != nil {
+		return fmt.Errorf("Can't write binary: %v", err)
+	}
+	buffer.Write(msg.Mtext)
+	_, _, errno := syscall.Syscall6(syscall.SYS_MSGSND,
 		uintptr(qid),
-		uintptr(unsafe.Pointer(&qbuf)),
+		uintptr(unsafe.Pointer(&buf[0])),
 		uintptr(len(msg.Mtext)),
 		uintptr(flags),
 		0,
 		0,
 	)
-	if err != 0 {
-		return err
+	if errno != 0 {
+		return errno
 	}
 	return nil
 }

msgsnd_test.go

@@ -40,7 +40,6 @@ func TestMsgsnd(t *testing.T) {
 				t.Fatal(err)
 			}
 		}(qid)
-
 		mtext := "hello"
 		done := make(chan struct{})
 		go func() {
@@ -52,6 +51,7 @@ func TestMsgsnd(t *testing.T) {
 			if want, got := mtext, string(qbuf.Mtext); want != got {
 				t.Fatalf("want %#v, got %#v", want, got)
 			}
+			fmt.Printf("Received: %s\n", string(qbuf.Mtext))
 			done <- struct{}{}
 		}()