Linux下GO语言内存共享,CGO实现

package ce

import (
	"errors"
	"fmt"
	"os"
	"os/exec"
)

/*
#include <stdio.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <string.h>

int Size;
int Shm_id;
key_t Key;
char *Shm_add;
int getMem(char *pathname,int size)
{
    Key = ftok((char *)pathname,0x03);
    if(Key==-1)
    {
        return -1;
    }
    Shm_id=shmget(Key,size,IPC_CREAT|IPC_EXCL|0600);
    if (Shm_id==-1)
    {
        return -2;
    }
    Shm_add=shmat(Shm_id,0,0);
    if (Shm_add==(void *)-1)
    {
	    return -3;
    }
    Size=size;
    return 0;
}
int close()
{
    int result;
    result=shmdt(Shm_add);
    if (result != 0)
    {
        return result;
    }
    result=shmctl(Shm_id, IPC_RMID, NULL);
    if (result != 0)
    {
        return result;
    }
    return 0;
}
int write(char *str)
{
        int len;
	len=strlen(str);
	if (len >= Size)
	{
		return 0;
	}
	strcpy((char *)Shm_add,(char *)str);
	return len;
}
char* read()
{
	return (char *)Shm_add;
}
*/
import "C"

type Mem struct {
	Shm_id C.int
	size   int
}

func GetShareMem(path string, size int) (*Mem, error) {
	info, err := os.Lstat(path)
	if err != nil {
		return nil, err
	}
	if info.IsDir() {
		return nil, errors.New("Must Is File")
	}
	cstr := C.CString(path)
        num := C.getMem(cstr, C.int(size))
        C.free(unsafe.Pointer(cstr))
	switch num {
	case 0:
		return &Mem{C.Shm_id, size}, nil
	case -1:
		return nil, errors.New("Get Key error")
	case -2:
		return nil, errors.New("Get Shm_id error")
	case -3:
		C.close()
		return nil, errors.New("Map AddrSpace error")
	}
	C.close()
	return nil, errors.New("Unknow error")
}

func (self *Mem) Close() error {
	num := C.close()
 	if num != 0 {
		cmd := exec.Command("ipcrm", "-m", fmt.Sprint(self.Shm_id))
		return cmd.Run()
	}
	return nil
}
func (self *Mem) Read() string {
	return C.GoString(C.read())
}
func (self *Mem) Write(body string) C.int {
    if len(body) > self.size {
        return C.int(0)
    }
    return C.write(C.CString(body))
}

package main

import (
	"flag"
	"fmt"
)

/*
#include <stdio.h>
#include <sys/shm.h>
#include <sys/ipc.h>
char* GetMem(int Shm_id)
{
    char *Shm_add;
    Shm_add=shmat(Shm_id,0,0);
    if (Shm_add==(void *)-1)
    {
        return (char *)-1;
    }
    return (char *)Shm_add;
}
int close(char *Shm_add)
{
	int result;
	result=shmdt(Shm_add);
    if (result != 0)
    {
        return result;
    }
}
*/
import "C"

type ShareMem struct {
	Addr *C.char
}

func main() {
	i := flag.Int("m", 0, "-m=12345")
	flag.Parse()
	x := GetShareMem(*i)
	if x == nil {
		fmt.Println("open error")
	}
	defer x.Close()
	fmt.Println(x.Read())
}

func GetShareMem(shm_id int) *ShareMem {
	m,err := C.GetMem(C.int(shm_id))
	if err != nil {
		return nil
	}
	return &ShareMem{m}
}

func (self *ShareMem) Close() {
	C.close(self.Addr)
}

func (self *ShareMem) Read() string {
	return C.GoString(self.Addr)
}

package main
import (
    "fmt"
    "ce"
)
func main() {
	m, err := ce.GetShareMem("/tmp/.tmpfile", 1024)
	if err != nil {
		fmt.Println(err)
	}
	defer m.Close()
	m.Write("fyxichen")
	fmt.Println(m.Read())
}