Example #1
2
//export sourceFill
func sourceFill(dinfo *C.struct_jpeg_decompress_struct) C.boolean {
	mgr := getSourceManager(dinfo)
	buffer := [readBufferSize]byte{}
	bytes, err := mgr.src.Read(buffer[:])
	C.memcpy(mgr.buffer, unsafe.Pointer(&buffer[0]), C.size_t(bytes))
	mgr.pub.bytes_in_buffer = C.size_t(bytes)
	mgr.currentSize = bytes
	mgr.pub.next_input_byte = (*C.JOCTET)(mgr.buffer)
	if err == io.EOF {
		if bytes == 0 {
			if mgr.startOfFile {
				releaseSourceManager(mgr)
				panic("input is empty")
			}
			// EOF and need more data. Fill in a fake EOI to get a partial image.
			footer := []byte{0xff, C.JPEG_EOI}
			C.memcpy(mgr.buffer, unsafe.Pointer(&footer[0]), C.size_t(len(footer)))
			mgr.pub.bytes_in_buffer = 2
		}
	} else if err != nil {
		releaseSourceManager(mgr)
		panic(err)
	}
	mgr.startOfFile = false

	return C.TRUE
}
Example #2
2
//export callback_friend_request
func callback_friend_request(
	c_tox *C.Tox,
	c_public_key *C.uint8_t,
	c_message *C.uint8_t,
	c_length C.size_t,
	c_user_data unsafe.Pointer,
) {
	// Initialize variables.
	tox := (*Tox)(c_user_data)
	var publicKey ToxPublicKey
	message := make([]byte, c_length)
	// Copy the public key.
	C.memcpy(
		unsafe.Pointer(&publicKey[0]),
		unsafe.Pointer(c_public_key),
		ToxPublicKeySize,
	)
	// Copy the friend request message.
	if c_length > 0 {
		C.memcpy(
			unsafe.Pointer(&message[0]),
			unsafe.Pointer(c_message),
			c_length,
		)
	}
	// Register the callback.
	tox.onFriendRequest(tox, publicKey, message)
}
Example #3
0
func fill_pdu_for_test_crypt(is_encrypt bool, pt C.enum_snmp_privacy, salt, key, data []byte) ([]byte, error) {
	var digest [100000]byte
	var pdu C.snmp_pdu_t

	C.snmp_pdu_init(&pdu)

	pdu.user.priv_proto = pt

	C.memcpy(unsafe.Pointer(&pdu.user.priv_key[0]), unsafe.Pointer(&key[0]), C.size_t(C.SNMP_PRIV_KEY_SIZ))
	pdu.user.priv_len = C.size_t(16) //C.size_t(C.SNMP_PRIV_KEY_SIZ) //(au == SNMP_PRIV_DES ) ? SNMP_AUTH_HMACMD5_KEY_SIZ : SNMP_AUTH_HMACSHA_KEY_SIZ;

	pdu.engine.engine_boots = 3
	pdu.engine.engine_time = 3
	C.memcpy(unsafe.Pointer(&pdu.msg_salt[0]), unsafe.Pointer(&salt[0]), 8)

	copy(digest[:], data)
	pdu.scoped_ptr = (*C.u_char)(unsafe.Pointer(&digest[0]))
	pdu.scoped_len = C.size_t((len(data) / 8) * 8)
	var ret_code C.enum_snmp_code
	if is_encrypt {
		ret_code = C.snmp_pdu_encrypt(&pdu)
	} else {
		ret_code = C.snmp_pdu_decrypt(&pdu)
	}
	if 0 != ret_code {
		err := errors.New(C.GoString(C.snmp_pdu_get_error(&pdu, ret_code)))
		return nil, err
	}

	return readGoBytes((*C.uint8_t)(pdu.scoped_ptr), C.uint32_t(pdu.scoped_len)), nil
}
Example #4
0
File: rmq.go Project: glycerine/rmq
//export ReadMsgpackFrame
//
// ReadMsgpackFrame reads the msgpack frame at byteOffset in rawStream, decodes the
// 2-5 bytes of a msgpack binary array (either bin8, bin16, or bin32), and returns
// and the decoded-into-R object and the next byteOffset to use.
//
func ReadMsgpackFrame(rawStream C.SEXP, byteOffset C.SEXP) C.SEXP {

	var start int
	if C.TYPEOF(byteOffset) == C.REALSXP {
		start = int(C.get_real_elt(byteOffset, 0))
	} else if C.TYPEOF(byteOffset) == C.INTSXP {
		start = int(C.get_int_elt(byteOffset, 0))
	} else {
		C.ReportErrorToR_NoReturn(C.CString("read.msgpack.frame(x, byteOffset) requires byteOffset to be a numeric byte-offset number."))
	}

	// rawStream must be a RAWSXP
	if C.TYPEOF(rawStream) != C.RAWSXP {
		C.ReportErrorToR_NoReturn(C.CString("read.msgpack.frame(x, byteOffset) requires x be a RAW vector of bytes."))
	}

	n := int(C.Rf_xlength(rawStream))
	if n == 0 {
		return C.R_NilValue
	}

	if start >= n {
		C.ReportErrorToR_NoReturn(C.CString(fmt.Sprintf("read.msgpack.frame(x, byteOffset) error: byteOffset(%d) is beyond the length of x (x has len %d).", start, n)))
	}

	var decoder [5]byte
	C.memcpy(unsafe.Pointer(&decoder[0]), unsafe.Pointer(C.get_raw_elt_ptr(rawStream, C.ulonglong(start))), C.size_t(5))
	headerSz, _, totalSz, err := DecodeMsgpackBinArrayHeader(decoder[:])
	if err != nil {
		C.ReportErrorToR_NoReturn(C.CString(fmt.Sprintf("ReadMsgpackFrame error trying to decode msgpack frame: %s", err)))
	}

	if start+totalSz > n {
		C.ReportErrorToR_NoReturn(C.CString(fmt.Sprintf("read.msgpack.frame(x, byteOffset) error: byteOffset(%d) plus the frames size(%d) goes beyond the length of x (x has len %d).", start, totalSz, n)))
	}

	bytes := make([]byte, totalSz)
	C.memcpy(unsafe.Pointer(&bytes[0]), unsafe.Pointer(C.get_raw_elt_ptr(rawStream, C.ulonglong(start))), C.size_t(totalSz))

	rObject := decodeMsgpackToR(bytes[headerSz:])
	C.Rf_protect(rObject)
	returnList := C.allocVector(C.VECSXP, C.R_xlen_t(2))
	C.Rf_protect(returnList)
	C.SET_VECTOR_ELT(returnList, C.R_xlen_t(0), C.Rf_ScalarReal(C.double(float64(start+totalSz))))
	C.SET_VECTOR_ELT(returnList, C.R_xlen_t(1), rObject)
	C.Rf_unprotect_ptr(rObject)
	C.Rf_unprotect_ptr(returnList)
	return returnList
}
Example #5
0
/*
Receive a message part from a socket.

For a description of flags, see: http://api.zeromq.org/2-2:zmq-recv#toc2
*/
func (soc *Socket) RecvBytes(flags Flag) ([]byte, error) {
	var msg C.zmq_msg_t
	if i, err := C.zmq_msg_init(&msg); i != 0 {
		return []byte{}, errget(err)
	}
	defer C.zmq_msg_close(&msg)

	var size C.int
	var err error

	var i C.int
	i, err = C.zmq_recv(soc.soc, &msg, C.int(flags))
	if i == 0 {
		size = C.int(C.zmq_msg_size(&msg))
	} else {
		size = -1
	}

	if size < 0 {
		return []byte{}, errget(err)
	}
	if size == 0 {
		return []byte{}, nil
	}
	data := make([]byte, int(size))
	C.memcpy(unsafe.Pointer(&data[0]), C.zmq_msg_data(&msg), C.size_t(size))
	return data, nil
}
Example #6
0
// Receive a message from the socket.
// int zmq_recv (void *s, zmq_msg_t *msg, int flags);
func (s *zmqSocket) Recv(flags SendRecvOption) (data []byte, err error) {
	// Allocate and initialise a new zmq_msg_t
	err = nil
	var m C.zmq_msg_t
	if C.zmq_msg_init(&m) != 0 {
		println("init")
		err = errno()
		return
	}
	defer C.zmq_msg_close(&m)
	// Receive into message
	if C.zmq_recvmsg(s.s, &m, C.int(flags)) != 0 {
		println("recvmsg")
		err = errno()
		return
	}
	// Copy message data into a byte array
	// FIXME Ideally this wouldn't require a copy.
	size := C.zmq_msg_size(&m)
	if size > 0 {
		data = make([]byte, int(size))
		C.memcpy(unsafe.Pointer(&data[0]), C.zmq_msg_data(&m), size)
	} else {
		data = nil
	}
	return
}
Example #7
0
func (m *AACDecoder) Decode(data []byte) (sample []byte, err error) {
	r := C.aacdec_decode(
		&m.m,
		(*C.uint8_t)(unsafe.Pointer(&data[0])),
		(C.int)(len(data)),
	)
	if int(r) < 0 {
		err = errors.New("decode failed")
		return
	}
	if int(m.m.got) == 0 {
		err = errors.New("no data")
		return
	}
	size := int(m.m.f.linesize[0]) * 2
	sample = make([]byte, size*2)
	for i := 0; i < 2; i++ {
		C.memcpy(
			unsafe.Pointer(&sample[i*size]),
			unsafe.Pointer(m.m.f.data[i]),
			(C.size_t)(size),
		)
	}
	return
}
Example #8
0
// NewTensor converts from a Go value to a Tensor. Valid values are scalars,
// slices, and arrays. Every element of a slice must have the same length so
// that the resulting Tensor has a valid shape.
func NewTensor(value interface{}) (*Tensor, error) {
	val := reflect.ValueOf(value)
	dims, dataType, err := dimsAndDataTypeOf(val.Type())
	if err != nil {
		return nil, err
	}
	// TODO(ashankar): Remove the bytes.Buffer and endcode directly into
	// C-memory, avoiding the memcpy and cutting down memory usage in half.
	shape := make([]int64, dims)
	buf := new(bytes.Buffer)
	if err := encodeTensor(buf, shape, val); err != nil {
		return nil, err
	}
	var shapePtr *C.int64_t
	if len(shape) > 0 {
		shapePtr = (*C.int64_t)(unsafe.Pointer(&shape[0]))
	}
	t := &Tensor{
		c:     C.TF_AllocateTensor(C.TF_DataType(dataType), shapePtr, C.int(len(shape)), C.size_t(buf.Len())),
		shape: shape,
	}
	runtime.SetFinalizer(t, (*Tensor).finalize)
	if buf.Len() > 0 {
		slice := buf.Bytes() // https://github.com/golang/go/issues/14210
		C.memcpy(C.TF_TensorData(t.c), unsafe.Pointer(&slice[0]), C.size_t(buf.Len()))
	}
	return t, nil
}
Example #9
0
func (d *Disassembler) Bytes() []byte {
	b := make([]byte, d.Len())
	C.memcpy(unsafe.Pointer(&b[0]),
		unsafe.Pointer(C.ud_insn_ptr(&d.u)),
		C.size_t(d.Len()))
	return b
}
Example #10
0
//export GoFileWrite
// Returns SQLite error code to be returned by xWrite:
//   SQLITE_OK: wrote n bytes
//   SQLITE_IOERR_WRITE: got error while writing
//   SQLITE_FULL: partial write
func GoFileWrite(fd C.int, src *C.char, n C.int, offset C.long) (rv int) {
	println("writing", n, "bytes at offset", offset, "to fd", fd)
	defer func() {
		println("write returning", rv)
	}()

	file := GetFile(int(fd))
	if file == nil {
		return C.SQLITE_IOERR_WRITE
	}

	// TODO: avoid this copy
	buf := make([]byte, n)
	C.memcpy(unsafe.Pointer(&buf[0]), unsafe.Pointer(src), C.size_t(len(buf)))

	nwritten, err := file.WriteAt(buf, int64(offset))
	if err != nil {
		if err == os.ENOSPC {
			return C.SQLITE_FULL
		}
		return C.SQLITE_IOERR_WRITE
	}
	if nwritten != int(n) {
		return C.SQLITE_IOERR_WRITE
	}

	return C.SQLITE_OK
}
Example #11
0
//export GoFileRead
// Returns SQLite error code to be returned by xRead:
//   SQLITE_OK: read n bytes
//   SQLITE_IOERR_READ: got error while reading
//   SQLITE_IOERR_SHORT_READ: read fewer than n bytes; rest will be zeroed
func GoFileRead(fd C.int, dst *C.char, n C.int, offset C.long) (rv int) {
	println("reading", n, "bytes at offset", offset, "from fd", fd)
	defer func() {
		println("read returning", rv)
	}()

	file := GetFile(int(fd))
	if file == nil {
		return C.SQLITE_IOERR_READ
	}

	buf := make([]byte, n)
	curbuf := buf
	for n > 0 {
		read, err := file.ReadAt(curbuf, int64(offset))
		curbuf = curbuf[read:]
		n -= C.int(read)
		if err == os.EOF {
			break
		}
		if err != nil {
			return C.SQLITE_IOERR_READ
		}
	}

	C.memcpy(unsafe.Pointer(dst), unsafe.Pointer(&buf[0]), C.size_t(len(buf)))

	if n != 0 {
		return C.SQLITE_IOERR_SHORT_READ
	}
	return C.SQLITE_OK
}
Example #12
0
func (p *Pcap) Next() (*Packet, os.Error) {
	var header *C.struct_pcap_pkthdr
	var buf *C.u_char
	switch C.pcap_next_ex(p.cptr, &header, &buf) {
	case 0:
		return nil, os.NewError("read time out")
	case -1:
		return nil, os.NewError(p.Geterror())
	case -2:
		return nil, os.NewError("savefile eof")
	}

	ret := new(Packet)
	ret.Time.Sec = int32(header.ts.tv_sec)
	ret.Time.Usec = int32(header.ts.tv_usec)
	ret.Caplen = uint32(header.caplen)
	ret.Len = uint32(header.len)
	ret.Data = make([]byte, header.caplen)

	if header.caplen > 0 {
		C.memcpy(unsafe.Pointer(&ret.Data[0]), unsafe.Pointer(buf), C.size_t(header.caplen))
	}

	return ret, nil
}
Example #13
0
// Compile pattern with jit compilation. flagC is Compile flags,
// flagS is study flag.
func CompileJIT(pattern string, flagsC, flagsS int) (Regexp, error) {
	patternC := C.CString(pattern)
	defer C.free(unsafe.Pointer(patternC))
	if clen := int(C.strlen(patternC)); clen != len(pattern) {
		return Regexp{}, fmt.Errorf("%s (%d): %s",
			pattern,
			clen,
			"NUL byte in pattern",
		)
	}
	var errptr *C.char
	var erroffset C.int
	ptr := C.pcre_compile(patternC, C.int(flagsC), &errptr, &erroffset, nil)
	if ptr == nil {
		return Regexp{}, fmt.Errorf("%s (%d): %s",
			pattern,
			int(erroffset),
			C.GoString(errptr),
		)
	}
	psize := pcresize(ptr)
	var re Regexp
	re.ptr = make([]byte, psize)
	C.memcpy(unsafe.Pointer(&re.ptr[0]), unsafe.Pointer(ptr), psize)
	errS := re.study(flagsS)
	if errS != nil {
		return re, fmt.Errorf("study error: %s", errS)
	}
	return re, nil
}
Example #14
0
func (self *Surface) ClipRectangleList() ([]Rectangle, Status) {
	list := C.cairo_copy_clip_rectangle_list(self.context)
	defer C.cairo_rectangle_list_destroy(list)
	rects := make([]Rectangle, int(list.num_rectangles))
	C.memcpy(unsafe.Pointer(&rects[0]), unsafe.Pointer(list.rectangles), C.size_t(list.num_rectangles*8))
	return rects, Status(list.status)
}
Example #15
0
//export aqbankingGetPasswordFn
func aqbankingGetPasswordFn(token *C.char, buffer unsafe.Pointer, minLen, maxLen int) int {
	pin, ok := knownAqbankingPins[C.GoString(token)]
	if ok {
		C.memcpy(buffer, unsafe.Pointer(C.CString(pin)), C.size_t(len(pin)))
	}
	return 0
}
Example #16
0
//export callback_friend_message
func callback_friend_message(
	c_tox *C.Tox,
	c_friend_number C.uint32_t,
	c_message_type C.TOX_MESSAGE_TYPE,
	c_message *C.uint8_t,
	c_length C.size_t,
	c_user_data unsafe.Pointer,
) {
	// Initialize variables.
	tox := (*Tox)(c_user_data)
	friendNumber := uint32(c_friend_number)
	var messageType ToxMessageType
	switch c_message_type {
	case C.TOX_MESSAGE_TYPE_NORMAL:
		messageType = ToxMessageTypeNormal
	case C.TOX_MESSAGE_TYPE_ACTION:
		messageType = ToxMessageTypeAction
	}
	message := make([]byte, c_length)
	// Copy the chat message.
	if c_length > 0 {
		C.memcpy(
			unsafe.Pointer(&message[0]),
			unsafe.Pointer(c_message),
			c_length,
		)
	}
	// Register the callback.
	tox.onFriendMessage(tox, friendNumber, messageType, message)
}
Example #17
0
/* int xs_recv (void *sck,void *buf,size_t len,int flags) */
func (sck *xsSocket) Recv(flags SocketOption) ([]byte, error, uint64) {

	var msg C.xs_msg_t
	r := C.xs_msg_init(&msg)
	if r != 0 {
		return nil, errno(), 0
	}

	defer C.xs_msg_close(&msg)

	r = C.xs_recvmsg(sck.sck, &msg, C.int(flags))
	if r == -1 {
		return nil, errno(), 0
	}
	size := C.xs_msg_size(&msg)
	var more uint64
	more_size := C.size_t(unsafe.Sizeof(more))
	C.xs_getmsgopt(&msg, C.XS_MORE, unsafe.Pointer(&more), &more_size)

	if size > 0 {
		data := make([]byte, int(size))
		C.memcpy(unsafe.Pointer(&data[0]), C.xs_msg_data(&msg), size)
		return data, nil, more
	}

	return nil, nil, more /* nothing to recv */
}
Example #18
0
// Move pattern to the Go heap so that we do not have to use a
// finalizer.  PCRE patterns are fully relocatable. (We do not use
// custom character tables.)
func toheap(ptr *C.pcre) (re Regexp) {
	defer C.free(unsafe.Pointer(ptr))
	size := pcresize(ptr)
	re.ptr = make([]byte, size)
	C.memcpy(unsafe.Pointer(&re.ptr[0]), unsafe.Pointer(ptr), size)
	return
}
Example #19
0
File: tpm.go Project: postfix/tpm
func (ctx *TPMContext) Random(n uint32) (rdata []byte, err error) {
	var randbytes *C.BYTE
	result := C.Tspi_TPM_GetRandom(ctx.tpm, C.UINT32(n), &randbytes)
	if result != C.TSS_SUCCESS {
		switch result {
		case C.TSS_E_INVALID_HANDLE:
			return nil, ErrInvalidHandle
		case C.TSS_E_INTERNAL_ERROR:
			return nil, ErrInternalError
		case C.TSS_E_BAD_PARAMETER:
			return nil, ErrBadParameter
		default:
			return nil, ErrUnknown

		}
	}

	rand := C.malloc(C.size_t(n))
	if rand != nil {
		C.memcpy(rand, unsafe.Pointer(randbytes), C.size_t(n))
		rdata = C.GoBytes(rand, C.int(n))
		C.free(rand)
	}
	C.Tspi_Context_FreeMemory(ctx.ctx, randbytes)
	return

}
Example #20
0
// Import imports the nodes and edges from a serialized representation of
// another Graph into g.
//
// Names of imported nodes will be prefixed with prefix.
func (g *Graph) Import(def []byte, prefix string) error {
	cprefix := C.CString(prefix)
	defer C.free(unsafe.Pointer(cprefix))

	opts := C.TF_NewImportGraphDefOptions()
	defer C.TF_DeleteImportGraphDefOptions(opts)
	C.TF_ImportGraphDefOptionsSetPrefix(opts, cprefix)

	buf := C.TF_NewBuffer()
	defer C.TF_DeleteBuffer(buf)
	// Would have preferred to use C.CBytes, but that does not play well
	// with "go vet" till https://github.com/golang/go/issues/17201 is
	// resolved.
	buf.length = C.size_t(len(def))
	buf.data = C.malloc(buf.length)
	if buf.data == nil {
		return fmt.Errorf("unable to allocate memory")
	}
	defer C.free(buf.data)
	C.memcpy(buf.data, unsafe.Pointer(&def[0]), buf.length)

	status := newStatus()
	C.TF_GraphImportGraphDef(g.c, buf, opts, status.c)
	if err := status.Err(); err != nil {
		return err
	}
	return nil
}
Example #21
0
//export go_ReadResponse
func go_ReadResponse(
	self *C.struct__cef_resource_handler_t,
	data_out unsafe.Pointer,
	bytes_to_read C.int,
	bytes_read *C.int,
	callback *C.struct__cef_callback_t) int {

	if handler, ok := handlerMap[unsafe.Pointer(self)]; ok {
		dataOut, bytesRead, result := handler.resourceHandler.ReadResponse(
			int(bytes_to_read),
			CefCallbackT{callback},
		)
		if len(dataOut) != bytesRead {
			panic(fmt.Sprintf("The response given to ReadResponse is invalid. bytes given %d is does not equal bytesRead %d", len(dataOut), bytesRead))
		}
		dataOutCString := C.CString(string(dataOut))
		defer C.free(unsafe.Pointer(dataOutCString))
		C.memcpy(data_out, unsafe.Pointer(dataOutCString), C.size_t(bytesRead))
		*bytes_read = C.int(bytesRead)
		return result
	}

	return 0

}
Example #22
0
// Receive a message from the socket.
// int zmq_recv (void *s, zmq_msg_t *msg, int flags);
func (s *Socket) Recv(flags SendRecvOption) (data []byte, err error) {
	// Allocate and initialise a new zmq_msg_t
	var m C.zmq_msg_t
	var rc C.int
	if rc, err = C.zmq_msg_init(&m); rc != 0 {
		err = casterr(err)
		return
	}
	defer C.zmq_msg_close(&m)
	// Receive into message
	if rc, err = C.zmq_recvmsg(s.s, &m, C.int(flags)); rc == -1 {
		err = casterr(err)
		return
	}
	err = nil
	// Copy message data into a byte array
	// FIXME Ideally this wouldn't require a copy.
	size := C.zmq_msg_size(&m)
	if size > 0 {
		data = make([]byte, int(size))
		C.memcpy(unsafe.Pointer(&data[0]), C.zmq_msg_data(&m), size)
	} else {
		data = nil
	}
	return
}
Example #23
0
File: codecCtx.go Project: tvib/gmf
func (this *CodecCtx) CopyExtra(ist *Stream) *CodecCtx {
	codec := this.avCodecCtx
	icodec := ist.CodecCtx().avCodecCtx

	codec.bits_per_raw_sample = icodec.bits_per_raw_sample
	codec.chroma_sample_location = icodec.chroma_sample_location

	codec.codec_id = icodec.codec_id
	codec.codec_type = icodec.codec_type

	// codec.codec_tag = icodec.codec_tag

	codec.rc_max_rate = icodec.rc_max_rate
	codec.rc_buffer_size = icodec.rc_buffer_size

	codec.field_order = icodec.field_order

	codec.extradata = (*_Ctype_uint8_t)(C.av_mallocz((_Ctype_size_t)((C.uint64_t)(icodec.extradata_size) + C.FF_INPUT_BUFFER_PADDING_SIZE)))

	C.memcpy(unsafe.Pointer(codec.extradata), unsafe.Pointer(icodec.extradata), (_Ctype_size_t)(icodec.extradata_size))
	codec.extradata_size = icodec.extradata_size
	codec.bits_per_coded_sample = icodec.bits_per_coded_sample

	codec.has_b_frames = icodec.has_b_frames

	return this
}
Example #24
0
// Return input with pattern replaced by sub.
func reSub(pattern []byte, sub []byte, input []byte) []byte {
	var err *C.GError = nil
	re := C.g_regex_new(
		(*C.gchar)(data(append(pattern, 0))),
		C.G_REGEX_CASELESS|
			C.G_REGEX_RAW|
			C.G_REGEX_NO_AUTO_CAPTURE|
			C.G_REGEX_OPTIMIZE,
		0,
		&err)
	if err != nil {
		panic("g_regex_new")
	}
	defer C.g_regex_unref(re)
	subd := C.g_regex_replace_literal(re, (*C.gchar)(data(input)),
		C.gssize(len(input)), 0, (*C.gchar)(data(sub)), 0, &err)
	if err != nil {
		panic("g_regex_replace_literal")
	}
	defer C.g_free(C.gpointer(subd))
	l := C.strlen((*C.char)(subd))
	rv := make([]byte, l)
	C.memcpy(data(rv), unsafe.Pointer(subd), l)
	return rv
}
Example #25
0
//export doLoad
func doLoad(
	self unsafe.Pointer,
	offset C.size_t,
	source unsafe.Pointer,
	length C.size_t) C.int {

	model := (*machine.Model)(self)

	// Bump up the size to the end of the page.
	new_length := platform.Align(uint64(length), platform.PageSize, true)

	// Allocate the backing data.
	data, err := model.Map(
		machine.MemoryTypeUser,
		platform.Paddr(offset),
		new_length,
		true)
	if err != nil {
		// Things are broken.
		log.Print("Error during ElfLoad: ", err)
		return -C.int(syscall.EINVAL)
	}

	// Copy the data in.
	C.memcpy(unsafe.Pointer(&data[0]), source, length)

	// All good.
	return 0
}
Example #26
0
func (msg *Msg) onDecode(pbData *C.BYTE, cbData C.DWORD, fFinal bool) error {
	if int(cbData) > msg.maxN {
		return fmt.Errorf("Buffer overrun on decoding")
	}
	C.memcpy(msg.data, unsafe.Pointer(pbData), C.size_t(cbData))
	msg.n = int(cbData)
	return nil
}
Example #27
0
//export goKvCursorCallback
func goKvCursorCallback(data unsafe.Pointer, b uint, fn unsafe.Pointer) int {
	if b == 0 {
		return 0
	}
	pdata := make([]byte, b)
	C.memcpy(unsafe.Pointer(&pdata[0]), data, C.size_t(b))
	f := *(*func([]byte) int)(fn)
	return f(pdata)
}
Example #28
0
// cairo_path_t* cairo_copy_path_flat (cairo_t *cr);
func (self *Surface) CopyPathFlat() (PathData, Status) {
	path := C.cairo_copy_path_flat(self.context)
	defer C.cairo_path_destroy(path)

	raw_data := make(PathData, int(path.num_data*2))
	C.memcpy(unsafe.Pointer(&raw_data[0]), unsafe.Pointer(path.data), C.size_t(path.num_data*16))

	return raw_data, Status(path.status)
}
Example #29
0
func (f *Face) CopyIndices() []uint32 {
	indices := make([]uint32, f.mNumIndices)
	if unsafe.Sizeof(C.uint(0)) != unsafe.Sizeof(uint32(0)) {
		panic("wrong size")
	}
	size := uint32(unsafe.Sizeof(C.uint(0))) * f.NumIndices()
	C.memcpy(unsafe.Pointer(&indices[0]), unsafe.Pointer(f.mIndices), C.size_t(size))
	return indices
}
Example #30
0
func DBFReadStringAttribute(h DBFHandle, shapeIndex, fieldIndex int) []byte {
	cstr := C.DBFReadStringAttribute(h, C.int(shapeIndex), C.int(fieldIndex))
	slen := int(C.strlen(cstr))
	bytes := make([]byte, slen)
	if slen > 0 {
		C.memcpy(unsafe.Pointer(&bytes[0]), unsafe.Pointer(cstr), C.size_t(slen))
	}
	return bytes
}