// FindGenericPassword finds the first generic password item which matches the
// attributes you provide. Most attributes are optional; you should pass only as
// many as you need to narrow the search sufficiently for your application's
// intended use.
func FindGenericPassword(service, account string) (string, error) {
	if service == "" || account == "" {
		return "", errors.New("service and account are required")
	}

	cService := C.CString(service)
	defer C.free(unsafe.Pointer(cService))

	cAccount := C.CString(account)
	defer C.free(unsafe.Pointer(cAccount))

	cPasswordLen := C.UInt32(0)
	cPassword := unsafe.Pointer(nil)

	errCode := C.SecKeychainFindGenericPassword(
		nil, // default keychain
		C.UInt32(C.strlen(cService)),
		cService,
		C.UInt32(C.strlen(cAccount)),
		cAccount,
		&cPasswordLen,
		&cPassword,
		nil,
	)

	if err := newKeychainError(errCode); err != nil {
		return "", err
	}

	defer C.SecKeychainItemFreeContent(nil, cPassword)

	return C.GoStringN((*C.char)(cPassword), C.int(cPasswordLen)), nil
}
Esempio n. 2
0
//export Go_callback
func Go_callback(playerInfo unsafe.Pointer, queue C.AudioQueueRef, buffer C.AudioQueueBufferRef) {
	audioData := ((*[1 << 30]byte)(unsafe.Pointer((*buffer).mAudioData)))[:buffer.mAudioDataBytesCapacity]
	pktDescs := (*[1 << 30]C.AudioStreamPacketDescription)(unsafe.Pointer(buffer.mPacketDescriptions))
	npackets := 0

	upto := audioData
	if peeked != nil {
		copy(upto, peeked)
		pktDescs[npackets].mStartOffset = C.SInt64(int64(len(audioData) - len(upto)))
		pktDescs[npackets].mDataByteSize = C.UInt32(int32(len(peeked)))
		upto = upto[len(peeked):]
		npackets++
	}

	peeked = <-packetsin
	for len(peeked) <= len(upto) {
		copy(upto, peeked)
		pktDescs[npackets].mStartOffset = C.SInt64(int64(len(audioData) - len(upto)))
		pktDescs[npackets].mDataByteSize = C.UInt32(int32(len(peeked)))
		pktDescs[npackets].mVariableFramesInPacket = C.UInt32(int32(0))
		upto = upto[len(peeked):]
		npackets++
		peeked = <-packetsin
	}

	buffer.mAudioDataByteSize = C.UInt32(len(audioData) - len(upto))
	buffer.mPacketDescriptionCount = C.UInt32(npackets)

	C.AudioQueueEnqueueBuffer(queue, buffer, 0, (*C.AudioStreamPacketDescription)(nil))
}
Esempio n. 3
0
func findGenericPasswordItem(attributes *GenericPasswordAttributes) (itemRef C.SecKeychainItemRef, err error) {
	if err = attributes.CheckValidity(); err != nil {
		return
	}

	serviceName := C.CString(attributes.ServiceName)
	defer C.free(unsafe.Pointer(serviceName))

	accountName := C.CString(attributes.AccountName)
	defer C.free(unsafe.Pointer(accountName))

	errCode := C.SecKeychainFindGenericPassword(
		nil, // default keychain
		C.UInt32(len(attributes.ServiceName)),
		serviceName,
		C.UInt32(len(attributes.AccountName)),
		accountName,
		nil,
		nil,
		&itemRef,
	)

	err = newKeychainError(errCode)
	return
}
Esempio n. 4
0
// FindGenericPassword finds a generic password with the given
// attributes in the default keychain and returns the password field
// if found. If not found, an error is returned.
func FindGenericPassword(attributes *GenericPasswordAttributes) ([]byte, error) {
	if err := attributes.CheckValidity(); err != nil {
		return nil, err
	}

	serviceName := C.CString(attributes.ServiceName)
	defer C.free(unsafe.Pointer(serviceName))

	accountName := C.CString(attributes.AccountName)
	defer C.free(unsafe.Pointer(accountName))

	var passwordLength C.UInt32

	var password unsafe.Pointer

	errCode := C.SecKeychainFindGenericPassword(
		nil, // default keychain
		C.UInt32(len(attributes.ServiceName)),
		serviceName,
		C.UInt32(len(attributes.AccountName)),
		accountName,
		&passwordLength,
		&password,
		nil,
	)

	if err := newKeychainError(errCode); err != nil {
		return nil, err
	}

	defer C.SecKeychainItemFreeContent(nil, password)

	return C.GoBytes(password, C.int(passwordLength)), nil
}
Esempio n. 5
0
// NewOutputWAVEFile opens a CoreAudio WAVE file suitable for output to target.
//
// rate is the sample rate, numchan is the number of channels in the output, and numbits is the number of bits per channel.
// NOTE: In order to prevent unnecessary copying, the calls to target use buffers that are owned by CoreAudio. This means that
// slices should not be made of buffers that will outlive the call to the WriteAt method.
func NewOutputWAVEFile(target ReadWriterAt, rate float64, numchan int, numbits int) (*AudioFile, error) {
	bpf := C.UInt32(numbits * numchan / 8)
	asbd := C.AudioStreamBasicDescription{
		mSampleRate:       C.Float64(rate),
		mFormatID:         C.kAudioFormatLinearPCM,
		mFormatFlags:      C.kAudioFormatFlagIsSignedInteger | C.kAudioFormatFlagIsPacked,
		mBytesPerPacket:   bpf,
		mFramesPerPacket:  1,
		mBytesPerFrame:    bpf,
		mChannelsPerFrame: C.UInt32(numchan),
		mBitsPerChannel:   C.UInt32(numbits),
	}
	return newOutputFile(target, &asbd, C.kAudioFileWAVEType)
}
Esempio n. 6
0
func (*keychainOSX) DeletePassword(service, account string) error {
	// Validate input
	serviceValid := isValidNonNullUTF8(service)
	accountValid := isValidNonNullUTF8(account)
	if !(serviceValid && accountValid) {
		return ErrInvalidValue
	}

	// Convert values to C strings
	serviceCStr := C.CString(service)
	defer C.free(unsafe.Pointer(serviceCStr))
	accountCStr := C.CString(account)
	defer C.free(unsafe.Pointer(accountCStr))

	// Grab the item
	var item C.SecKeychainItemRef
	status := C.SecKeychainFindGenericPassword(
		nil,
		C.UInt32(len(service)),
		serviceCStr,
		C.UInt32(len(account)),
		accountCStr,
		nil,
		nil,
		&item,
	)

	// Check for errors
	if status != C.errSecSuccess {
		return ErrNotFound
	}

	// Delete the item
	status = C.SecKeychainItemDelete(item)

	// Free the item
	C.CFRelease(C.CFTypeRef(item))

	// Check for errors
	if status != C.errSecSuccess {
		return ErrUnknown
	}

	// All done
	return nil
}
// FindInternetPassword function finds the first Internet password item which
// matches the attributes you provide. Most attributes are optional; you should
// pass only as many as you need to narrow the search sufficiently for your
// application's intended use. SecKeychainFindInternetPassword optionally
// returns a reference to the found item.
func FindInternetPassword(server, domain, account, path string, port uint16, protocol ProtocolType, authType AuthenticationType) (string, error) {
	if server == "" || account == "" {
		return "", errors.New("server and account are required")
	}

	cServer := C.CString(server)
	defer C.free(unsafe.Pointer(cServer))

	cDomain := C.CString(domain)
	defer C.free(unsafe.Pointer(cDomain))

	cAccount := C.CString(account)
	defer C.free(unsafe.Pointer(cAccount))

	cPath := C.CString(path)
	defer C.free(unsafe.Pointer(cPath))

	cPasswordLen := C.UInt32(0)
	cPassword := unsafe.Pointer(nil)

	errCode := C.SecKeychainFindInternetPassword(
		nil, // default keychain,
		C.UInt32(C.strlen(cServer)),
		cServer,
		C.UInt32(C.strlen(cDomain)),
		cDomain,
		C.UInt32(C.strlen(cAccount)),
		cAccount,
		C.UInt32(C.strlen(cPath)),
		cPath,
		C.UInt16(port),
		C.SecProtocolType(protocol),
		C.SecAuthenticationType(authType),
		&cPasswordLen,
		&cPassword,
		nil,
	)

	if err := newKeychainError(errCode); err != nil {
		return "", err
	}

	defer C.SecKeychainItemFreeContent(nil, cPassword)

	return C.GoStringN((*C.char)(cPassword), C.int(cPasswordLen)), nil
}
Esempio n. 8
0
// NewOutputAACFile opens a CoreAudio MP4 encapsulated AAC file suitable for output to target.
//
// rate is the sample rate, numchan is the number of channels in the output, and numbits is the number of bits per channel.
// NOTE: In order to prevent unnecessary copying, the calls to target use buffers that are owned by CoreAudio. This means that
// slices should not be made of buffers that will outlive the call to the WriteAt method.
func NewOutputAACFile(target ReadWriterAt, rate float64, numchan int, numbits int) (*AudioFile, error) {
	asbd := C.AudioStreamBasicDescription{
		mSampleRate:       C.Float64(rate),
		mFormatID:         C.kAudioFormatMPEG4AAC,
		mFormatFlags:      C.kMPEG4Object_AAC_Main,
		mChannelsPerFrame: C.UInt32(numchan),
		mFramesPerPacket:  1024,
	}
	return newOutputFile(target, &asbd, C.kAudioFileM4AType)
}
Esempio n. 9
0
func (*keychainOSX) GetPassword(service, account string) (string, error) {
	// Validate input
	serviceValid := isValidNonNullUTF8(service)
	accountValid := isValidNonNullUTF8(account)
	if !(serviceValid && accountValid) {
		return "", ErrInvalidValue
	}

	// Convert values to C strings
	serviceCStr := C.CString(service)
	defer C.free(unsafe.Pointer(serviceCStr))
	accountCStr := C.CString(account)
	defer C.free(unsafe.Pointer(accountCStr))

	// Look for a match
	var passwordData unsafe.Pointer
	var passwordDataLength C.UInt32
	status := C.SecKeychainFindGenericPassword(
		nil,
		C.UInt32(len(service)),
		serviceCStr,
		C.UInt32(len(account)),
		accountCStr,
		&passwordDataLength,
		&passwordData,
		nil,
	)

	// Check for errors
	if status != C.errSecSuccess {
		return "", ErrNotFound
	}

	// Create the result
	result := C.GoStringN((*C.char)(passwordData), C.int(passwordDataLength))

	// Cleanup the temporary buffer
	C.SecKeychainItemFreeContent(nil, passwordData)

	// All done
	return result, nil
}
Esempio n. 10
0
// The returned SecKeychainRef, if non-nil, must be released via CFRelease.
func createKeychain(path string, promptUser bool, password string) (C.SecKeychainRef, error) {
	pathName := C.CString(path)
	defer C.free(unsafe.Pointer(pathName))

	var kref C.SecKeychainRef
	var errCode C.OSStatus

	if promptUser {
		errCode = C.SecKeychainCreate(pathName, C.UInt32(0), nil, C.Boolean(1), nil, &kref)
	} else {
		passwordRef := C.CString(password)
		defer C.free(unsafe.Pointer(passwordRef))
		errCode = C.SecKeychainCreate(pathName, C.UInt32(len(password)), unsafe.Pointer(passwordRef), C.Boolean(0), nil, &kref)
	}

	if err := newKeychainError(errCode); err != nil {
		return nil, err
	}

	return kref, nil
}
Esempio n. 11
0
func (*keychainOSX) AddPassword(service, account, password string) error {
	// Validate input
	serviceValid := isValidNonNullUTF8(service)
	accountValid := isValidNonNullUTF8(account)
	passwordValid := isValidNonNullUTF8(password)
	if !(serviceValid && accountValid && passwordValid) {
		return ErrInvalidValue
	}

	// Convert values to C strings
	serviceCStr := C.CString(service)
	defer C.free(unsafe.Pointer(serviceCStr))
	accountCStr := C.CString(account)
	defer C.free(unsafe.Pointer(accountCStr))
	passwordBlob := unsafe.Pointer(C.CString(password))
	defer C.free(passwordBlob)

	// Try to add the password
	status := C.SecKeychainAddGenericPassword(
		nil,
		C.UInt32(len(service)),
		serviceCStr,
		C.UInt32(len(account)),
		accountCStr,
		C.UInt32(len(password)),
		passwordBlob,
		nil,
	)

	// Check for errors
	if status != C.errSecSuccess {
		return ErrUnknown
	}

	// All done
	return nil
}
Esempio n. 12
0
func newKeychain(path, password string, promptUser bool) (Keychain, error) {
	pathRef := C.CString(path)
	defer C.free(unsafe.Pointer(pathRef))

	var errCode C.OSStatus
	var kref C.SecKeychainRef

	if promptUser {
		errCode = C.SecKeychainCreate(pathRef, C.UInt32(0), nil, C.Boolean(1), nil, &kref)
	} else {
		passwordRef := C.CString(password)
		defer C.free(unsafe.Pointer(passwordRef))
		errCode = C.SecKeychainCreate(pathRef, C.UInt32(len(password)), unsafe.Pointer(passwordRef), C.Boolean(0), nil, &kref)
	}

	// TODO: Without passing in kref I get 'One or more parameters passed to the function were not valid (-50)'
	defer Release(C.CFTypeRef(kref))

	if err := checkError(errCode); err != nil {
		return Keychain{}, err
	}

	return Keychain{path}, nil
}
Esempio n. 13
0
//export go_audiofile_readproc
func go_audiofile_readproc(data unsafe.Pointer, inPosition C.SInt64, requestCount C.UInt32, buffer unsafe.Pointer, actualCount *C.UInt32) C.OSStatus {
	af := (*AudioFile)(data)
	length := int(requestCount)
	hdr := reflect.SliceHeader{
		Data: uintptr(buffer),
		Len:  length,
		Cap:  length,
	}
	bslice := *(*[]byte)(unsafe.Pointer(&hdr))
	n, err := af.target.ReadAt(bslice, int64(inPosition))
	*actualCount = C.UInt32(n)
	if err == io.EOF {
		return C.kAudioFileEndOfFileError
	} else if err != nil {
		return C.kAudioFileUnspecifiedError
	}
	return C.OSStatus(0)
}
Esempio n. 14
0
// The byte array returned by this function is unsafe.
// It is mapped to a C buffer, which can be erased/overwritten
// when Close, ExtractUnsafe,or any function that calls ExtractUnsafe is called.
// Unless your data is too big, and you are prepared to
// avoid using another call to mentioned functions during the life-time of
// the returned array, do not use this function.
func (z *SevenZip) ExtractUnsafe(i int) ([]byte, error) {
	var outSizeProcessed, offset C.size_t

	if C.SzArEx_Extract(
		&z.db, &z.lookStream.s, C.UInt32(i),
		&z.blockIndex, &z.outBuffer, &z.outBufferSize,
		&offset, &outSizeProcessed,
		&z.allocImp, &z.allocTempImp) != C._SZ_OK {
		return []byte{}, errors.New("sevenzip: extract failed")
	}

	cbuf := C._ByteArrayIndex(z.outBuffer, offset)
	clen := int(outSizeProcessed)

	file := (*[1 << 30]byte)(unsafe.Pointer(cbuf))[:clen]
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&file))
	hdr.Cap = clen
	hdr.Len = clen

	return file, nil
}
Esempio n. 15
0
//export go_audiofile_writeproc
func go_audiofile_writeproc(data unsafe.Pointer, inPosition C.SInt64, requestCount C.UInt32, buffer unsafe.Pointer, actualCount *C.UInt32) C.OSStatus {
	af := (*AudioFile)(data)
	length := int(requestCount)
	hdr := reflect.SliceHeader{
		Data: uintptr(buffer),
		Len:  length,
		Cap:  length,
	}
	bslice := *(*[]byte)(unsafe.Pointer(&hdr))
	npos := int64(inPosition)

	n, err := af.target.WriteAt(bslice, npos)
	*actualCount = C.UInt32(n)
	if err != nil {
		return C.kAudioFileUnspecifiedError
	}
	if npos+int64(n) > af.fileSize {
		af.fileSize = npos + int64(n)
	}

	return C.OSStatus(0)
}