Golang C.close类(方法)实例源码

func (w *window) newBuffer(width, height int,
	format uint32) *C.struct_wl_buffer {

	stride := width * 4
	size := stride * height

	fd := C.os_create_anonymous_file(C.off_t(size))
	if fd < 0 {
		panic("Could not create buffer file.")
	}

	data := C.mmap(nil, C.size_t(size), C.PROT_READ|C.PROT_WRITE,
		C.MAP_SHARED, C.int(fd), 0)
	if *(*int)(data) == -1 {
		panic("mmap failed")
		C.close(fd)
		return nil
	}

	pool := C.wl_shm_create_pool(w.display.shm,
		C.int32_t(fd), C.int32_t(size))
	buffer := C.wl_shm_pool_create_buffer(pool, 0,
		C.int32_t(width), C.int32_t(height),
		C.int32_t(stride), C.uint32_t(format))
	C.wl_shm_pool_destroy(pool)
	C.close(fd)

	w.shmData = data
	return buffer
}

func (s *journald) followJournal(logWatcher *logger.LogWatcher, config logger.ReadConfig, j *C.sd_journal, pfd [2]C.int, cursor string) {
	s.readers.mu.Lock()
	s.readers.readers[logWatcher] = logWatcher
	s.readers.mu.Unlock()
	go func() {
		// Keep copying journal data out until we're notified to stop
		// or we hit an error.
		status := C.wait_for_data_or_close(j, pfd[0])
		for status == 1 {
			cursor = s.drainJournal(logWatcher, config, j, cursor)
			status = C.wait_for_data_or_close(j, pfd[0])
		}
		if status < 0 {
			cerrstr := C.strerror(C.int(-status))
			errstr := C.GoString(cerrstr)
			fmtstr := "error %q while attempting to follow journal for container %q"
			logrus.Errorf(fmtstr, errstr, s.vars["CONTAINER_ID_FULL"])
		}
		// Clean up.
		C.close(pfd[0])
		s.readers.mu.Lock()
		delete(s.readers.readers, logWatcher)
		s.readers.mu.Unlock()
		C.sd_journal_close(j)
		close(logWatcher.Msg)
	}()
	// Wait until we're told to stop.
	select {
	case <-logWatcher.WatchClose():
		// Notify the other goroutine that its work is done.
		C.close(pfd[1])
	}
}

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 (rw *RWops) Close() error {
	if C.close(rw.c) != 0 {
		return getError()
	}

	return nil
}

// close a file descriptor
func fdClose(fd C.int) (err error) {
	res := C.close(fd)
	if res == C.int(-1) {
		err = errors.New("close returned -1")
	}
	return
}

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
}

// Close cleans up the TPacket.  It should not be used after the Close call.
func (h *TPacket) Close() {
	if h.fd == -1 {
		return // already closed.
	}
	if h.ring != nil {
		C.munmap(h.ring, C.size_t(h.opts.blockSize*h.opts.numBlocks))
	}
	h.ring = nil
	C.close(h.fd)
	h.fd = -1
	runtime.SetFinalizer(h, nil)
}

func (s *journald) followJournal(logWatcher *logger.LogWatcher, config logger.ReadConfig, j *C.sd_journal, pfd [2]C.int, cursor string) {
	go func() {
		// Keep copying journal data out until we're notified to stop.
		for C.wait_for_data_or_close(j, pfd[0]) == 1 {
			cursor = s.drainJournal(logWatcher, config, j, cursor)
		}
		// Clean up.
		C.close(pfd[0])
		s.readers.mu.Lock()
		delete(s.readers.readers, logWatcher)
		s.readers.mu.Unlock()
	}()
	s.readers.mu.Lock()
	s.readers.readers[logWatcher] = logWatcher
	s.readers.mu.Unlock()
	// Wait until we're told to stop.
	select {
	case <-logWatcher.WatchClose():
		// Notify the other goroutine that its work is done.
		C.close(pfd[1])
	}
}

func AuditLogUserEvent(event_type int, message string, result bool) error {
	var r int
	fd := C.audit_open()
	if result {
		r = 1
	} else {
		r = 0
	}
	if fd > 0 {
		cmsg := C.CString(message)
		_, err := C.audit_log_user_message(fd, C.int(event_type), cmsg, nil, nil, nil, C.int(r))
		C.free(unsafe.Pointer(cmsg))
		C.close(fd)
		return err
	}
	return nil
}

func main() {
	fd, err := C.my_shm_open(C.CString(SHM_NAME))
	if err != nil {
		fmt.Println(err)
		return
	}

	ptr, err := C.mmap(nil, SHM_SIZE, C.PROT_READ|C.PROT_WRITE, C.MAP_SHARED, fd, 0)
	if err != nil {
		fmt.Println(err)
		return
	}
	C.close(fd)

	data := (*MyData)(unsafe.Pointer(ptr))

	fmt.Println(data)
}

func main() {
	devId := C.hci_get_route(nil)
	sock := C.hci_open_dev(devId)
	defer C.close(sock)

	if devId < 0 || sock < 0 {
		fmt.Println("Error opening socket for Bluetooth connection.")
		fmt.Println("Ensure Bluetooth is enabled.")
		os.Exit(1)
	}
	fmt.Println("Searching for Bluetooth devices...")
	flags := C.IREQ_CACHE_FLUSH
	maxRsp := 255
	var ii *C.inquiry_info
	iisize := unsafe.Sizeof(ii)
	iiptr := (*C.inquiry_info)(C.malloc(C.size_t(maxRsp) * C.size_t(iisize)))
	defer C.free(unsafe.Pointer(iiptr))

	numRsp := int(C.hci_inquiry(devId, 8, 255, nil, &iiptr, C.long(flags)))
	if numRsp <= 0 {
		fmt.Println("Unable to find Bluetooth devices.")
		os.Exit(0)
	}

	fmt.Printf("Found %d Bluetooth device(s)\n", numRsp)
	var addr [19]C.char
	var devAddr string
	var name [248]C.char
	var devName string
	for i := 0; i < numRsp; i++ {
		ptrOffset := uintptr(unsafe.Pointer(iiptr)) + (uintptr(iisize) * uintptr(i))
		ii = (*C.inquiry_info)(unsafe.Pointer(ptrOffset))
		C.ba2str(&ii.bdaddr, &addr[0])
		devAddr = C.GoString(&addr[0])
		result := C.hci_read_remote_name(sock, &ii.bdaddr, C.int(len(name)), &name[0], 0)
		if result < 0 {
			devName = "UNKNOWN"
		} else {
			devName = C.GoString(&name[0])
		}
		fmt.Printf("Device %s - %s\n", devName, devAddr)
	}
}

func main() {
	fd, err := C.my_shm_new(C.CString(SHM_NAME))
	if err != nil {
		fmt.Println(err)
		return
	}

	C.ftruncate(fd, SHM_SIZE)

	ptr, err := C.mmap(nil, SHM_SIZE, C.PROT_READ|C.PROT_WRITE, C.MAP_SHARED, fd, 0)
	if err != nil {
		fmt.Println(err)
		return
	}
	C.close(fd)

	data := (*MyData)(unsafe.Pointer(ptr))

	data.Col1 = 500
	data.Col2 = 200
	data.Col3 = 100
}

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

func (self NamedPort) Ethernet() (PortEthernetProperty, error) {
	switch self.hatype {
	case 0:
		return PortEthernetProperty{}, nil
	case syscall.ARPHRD_ETHER:
		// pass
	default:
		return PortEthernetProperty{}, fmt.Errorf("%s not an ether", self.name)
	}

	cname := C.CString(self.name)
	defer C.free(unsafe.Pointer(cname))

	fd := C.socket(C.AF_INET, C.SOCK_DGRAM, 0)
	defer C.close(fd)

	state := PortEthernetProperty{}

	ecmd := C.struct_ethtool_cmd{cmd: C.ETHTOOL_GSET}
	if r, err := C.ethtool_cmd_call(fd, cname, &ecmd); err != nil {
		return state, fmt.Errorf("ethtool for %s: %s", self.name, err.Error())
	} else if r != 0 {
		return state, fmt.Errorf("ethtool_cmd_call error")
	} else {
		for k, v := range supportedSpeed {
			if ecmd.supported&k != 0 && v > state.MaxSpeed {
				state.MaxSpeed = v
			}
		}
		state.Supported = 0
		for k, v := range supportedConvert {
			if ecmd.supported&k != 0 {
				state.Supported |= v
			}
		}
		state.Advertised = 0
		state.Peer = 0
		for k, v := range advertisedConvert {
			if ecmd.advertising&k != 0 {
				state.Advertised |= v
			}
			if ecmd.lp_advertising&k != 0 {
				state.Peer |= v
			}
		}

		var curr uint32
		switch C.ethtool_cmd_speed(&ecmd) {
		case C.SPEED_10:
			state.CurrSpeed = 10000
			switch ecmd.duplex {
			case C.DUPLEX_HALF:
				curr |= ofp4.OFPPF_10MB_HD
			case C.DUPLEX_FULL:
				curr |= ofp4.OFPPF_10MB_FD
			default:
				curr |= ofp4.OFPPF_OTHER
			}
		case C.SPEED_100:
			state.CurrSpeed = 100000
			switch ecmd.duplex {
			case C.DUPLEX_HALF:
				curr |= ofp4.OFPPF_100MB_HD
			case C.DUPLEX_FULL:
				curr |= ofp4.OFPPF_100MB_FD
			default:
				curr |= ofp4.OFPPF_OTHER
			}
		case C.SPEED_1000:
			state.CurrSpeed = 1000000
			switch ecmd.duplex {
			case C.DUPLEX_HALF:
				curr |= ofp4.OFPPF_1GB_HD
			case C.DUPLEX_FULL:
				curr |= ofp4.OFPPF_1GB_FD
			default:
				curr |= ofp4.OFPPF_OTHER
			}
		case C.SPEED_10000:
			state.CurrSpeed = 1000000
			switch ecmd.duplex {
			case C.DUPLEX_FULL:
				curr |= ofp4.OFPPF_10GB_FD
			default:
				curr |= ofp4.OFPPF_OTHER
			}
		default:
			curr |= ofp4.OFPPF_OTHER
		}
		switch ecmd.port {
		case C.PORT_TP:
			curr |= ofp4.OFPPF_COPPER
		case C.PORT_FIBRE:
			curr |= ofp4.OFPPF_FIBER
		}
		if ecmd.autoneg != C.AUTONEG_DISABLE {
			curr |= ofp4.OFPPF_AUTONEG
		}
		state.Curr = curr
	}
//.........这里部分代码省略.........