_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q9200 | NewSecuredDevice | train | func NewSecuredDevice(name string, pin string, database db.Database) (SecuredDevice, error) {
d, err := NewDevice(name, database)
return &securedDevice{d, pin}, err
} | go | {
"resource": ""
} |
q9201 | AddAccessory | train | func (m *Container) AddAccessory(a *Accessory) {
a.UpdateIDs()
a.SetID(m.idCount)
m.idCount++
m.Accessories = append(m.Accessories, a)
} | go | {
"resource": ""
} |
q9202 | RemoveAccessory | train | func (m *Container) RemoveAccessory(a *Accessory) {
for i, accessory := range m.Accessories {
if accessory == a {
m.Accessories = append(m.Accessories[:i], m.Accessories[i+1:]...)
}
}
} | go | {
"resource": ""
} |
q9203 | Equal | train | func (m *Container) Equal(other interface{}) bool {
if container, ok := other.(*Container); ok == true {
if len(m.Accessories) != len(container.Accessories) {
return false
}
for i, a := range m.Accessories {
if a.Equal(container.Accessories[i]) == false {
return false
}
}
return true
}
return false
} | go | {
"resource": ""
} |
q9204 | AccessoryType | train | func (m *Container) AccessoryType() AccessoryType {
if as := m.Accessories; len(as) > 0 {
if len(as) > 1 {
return TypeBridge
}
return as[0].Type
}
return TypeOther
} | go | {
"resource": ""
} |
q9205 | NewSetupServerController | train | func NewSetupServerController(device hap.SecuredDevice, database db.Database) (*SetupServerController, error) {
if len(device.PrivateKey()) == 0 {
return nil, errors.New("no private key for pairing available")
}
session, err := NewSetupServerSession(device.Name(), device.Pin())
if err != nil {
return nil, err
}
controller := SetupServerController{
device: device,
session: session,
database: database,
step: PairStepWaiting,
}
return &controller, nil
} | go | {
"resource": ""
} |
q9206 | NewPairVerify | train | func NewPairVerify(context hap.Context, database db.Database) *PairVerify {
endpoint := PairVerify{
context: context,
database: database,
}
return &endpoint
} | go | {
"resource": ""
} |
q9207 | HandleGetAccessories | train | func (ctr *ContainerController) HandleGetAccessories(r io.Reader) (io.Reader, error) {
result, err := json.Marshal(ctr.container)
return bytes.NewBuffer(result), err
} | go | {
"resource": ""
} |
q9208 | New | train | func New(info Info, typ AccessoryType) *Accessory {
svc := service.NewAccessoryInformation()
if name := info.Name; len(name) > 0 {
svc.Name.SetValue(name)
} else {
svc.Name.SetValue("undefined")
}
if serial := info.SerialNumber; len(serial) > 0 {
svc.SerialNumber.SetValue(serial)
} else {
svc.SerialNumber.SetValue("undefined")
}
if manufacturer := info.Manufacturer; len(manufacturer) > 0 {
svc.Manufacturer.SetValue(manufacturer)
} else {
svc.Manufacturer.SetValue("undefined")
}
if model := info.Model; len(model) > 0 {
svc.Model.SetValue(model)
} else {
svc.Model.SetValue("undefined")
}
if version := info.FirmwareRevision; len(version) > 0 {
svc.FirmwareRevision.SetValue(version)
} else {
svc.FirmwareRevision.SetValue("undefined")
}
acc := &Accessory{
idCount: 1,
Info: svc,
Type: typ,
}
acc.AddService(acc.Info.Service)
svc.Identify.OnValueRemoteUpdate(func(value bool) {
acc.Identify()
})
return acc
} | go | {
"resource": ""
} |
q9209 | AddService | train | func (a *Accessory) AddService(s *service.Service) {
a.Services = append(a.Services, s)
} | go | {
"resource": ""
} |
q9210 | UpdateIDs | train | func (a *Accessory) UpdateIDs() {
for _, s := range a.Services {
s.SetID(a.idCount)
a.idCount++
for _, c := range s.Characteristics {
c.SetID(a.idCount)
a.idCount++
}
}
} | go | {
"resource": ""
} |
q9211 | Equal | train | func (a *Accessory) Equal(other interface{}) bool {
if accessory, ok := other.(*Accessory); ok == true {
if len(a.Services) != len(accessory.Services) {
return false
}
for i, s := range a.Services {
if s.Equal(accessory.Services[i]) == false {
return false
}
}
return a.ID == accessory.ID
}
return false
} | go | {
"resource": ""
} |
q9212 | isPaired | train | func (t *ipTransport) isPaired() bool {
// If more than one entity is stored in the database, we are paired with a device.
// The transport itself is a device and is stored in the database, therefore
// we have to check for more than one entity.
if es, err := t.database.Entities(); err == nil && len(es) > 1 {
return true
}
return false
} | go | {
"resource": ""
} |
q9213 | Handle | train | func (t *ipTransport) Handle(ev interface{}) {
switch ev.(type) {
case event.DevicePaired:
log.Debug.Printf("Event: paired with device")
t.updateMDNSReachability()
case event.DeviceUnpaired:
log.Debug.Printf("Event: unpaired with device")
t.updateMDNSReachability()
default:
break
}
} | go | {
"resource": ""
} |
q9214 | NewLightbulb | train | func NewLightbulb(info Info) *Lightbulb {
acc := Lightbulb{}
acc.Accessory = New(info, TypeLightbulb)
acc.Lightbulb = service.NewLightbulb()
acc.Lightbulb.Brightness.SetValue(100)
acc.AddService(acc.Lightbulb.Service)
return &acc
} | go | {
"resource": ""
} |
q9215 | OnTermination | train | func OnTermination(fn TermFunc) {
c := make(chan os.Signal)
signal.Notify(c, os.Interrupt)
signal.Notify(c, os.Kill)
signal.Notify(c, syscall.SIGTERM)
go func() {
select {
case <-c:
if fn != nil {
fn()
}
}
}()
} | go | {
"resource": ""
} |
q9216 | MAC48Address | train | func MAC48Address(input string) string {
h := md5.New()
h.Write([]byte(input))
result := h.Sum(nil)
var c []string
c = append(c, toHex(result[0]))
c = append(c, toHex(result[1]))
c = append(c, toHex(result[2]))
c = append(c, toHex(result[3]))
c = append(c, toHex(result[4]))
c = append(c, toHex(result[5]))
return strings.ToUpper(strings.Join(c, ":"))
} | go | {
"resource": ""
} |
q9217 | NewCharacteristicNotification | train | func NewCharacteristicNotification(a *accessory.Accessory, c *characteristic.Characteristic) (*http.Response, error) {
body, err := Body(a, c)
if err != nil {
return nil, err
}
return NewNotification(body), nil
} | go | {
"resource": ""
} |
q9218 | NewNotification | train | func NewNotification(body *bytes.Buffer) *http.Response {
resp := new(http.Response)
resp.Status = "200 OK"
resp.StatusCode = http.StatusOK
resp.ProtoMajor = 1
resp.ProtoMinor = 0
resp.Body = ioutil.NopCloser(body)
resp.ContentLength = int64(body.Len())
resp.Header = map[string][]string{}
resp.Header.Set("Content-Type", HTTPContentTypeHAPJson)
// Will be ignored unfortunately and won't be fixed https://github.com/golang/go/issues/9304
// Make sure to call FixProtocolSpecifier() instead
resp.Proto = "EVENT/1.0"
return resp
} | go | {
"resource": ""
} |
q9219 | Body | train | func Body(a *accessory.Accessory, c *characteristic.Characteristic) (*bytes.Buffer, error) {
ch := data.Characteristic{AccessoryID: a.GetID(), CharacteristicID: c.GetID(), Value: c.Value}
chars := data.Characteristics{[]data.Characteristic{ch}}
result, err := json.Marshal(chars)
if err != nil {
return nil, err
}
var b bytes.Buffer
b.Write(result)
return &b, err
} | go | {
"resource": ""
} |
q9220 | Sha512 | train | func Sha512(master, salt, info []byte) ([32]byte, error) {
hash := sha512.New
hkdf := hkdf.New(hash, master, salt, info)
key := make([]byte, 32) // 256 bit
_, err := io.ReadFull(hkdf, key)
var result [32]byte
copy(result[:], key)
return result, err
} | go | {
"resource": ""
} |
q9221 | NewAccessories | train | func NewAccessories(c hap.AccessoriesHandler, mutex *sync.Mutex) *Accessories {
handler := Accessories{
controller: c,
mutex: mutex,
}
return &handler
} | go | {
"resource": ""
} |
q9222 | NewTLV8ContainerFromReader | train | func NewTLV8ContainerFromReader(r io.Reader) (Container, error) {
var items = make([]tlv8, 0, 1)
for r != nil {
var item tlv8
if err := binary.Read(r, binary.LittleEndian, &item.tag); err != nil {
if err == io.EOF {
break
}
return nil, err
}
if err := binary.Read(r, binary.LittleEndian, &item.length); err != nil {
return nil, err
}
item.value = make([]byte, item.length)
if err := binary.Read(r, binary.LittleEndian, &item.value); err != nil {
return nil, err
}
items = append(items, item)
}
return &tlv8Container{
Items: items,
}, nil
} | go | {
"resource": ""
} |
q9223 | NewSession | train | func NewSession(connection net.Conn) Session {
s := session{
connection: connection,
}
return &s
} | go | {
"resource": ""
} |
q9224 | NewOutlet | train | func NewOutlet(info Info) *Outlet {
acc := Outlet{}
acc.Accessory = New(info, TypeOutlet)
acc.Outlet = service.NewOutlet()
acc.Outlet.OutletInUse.SetValue(true)
acc.AddService(acc.Outlet.Service)
return &acc
} | go | {
"resource": ""
} |
q9225 | NewPairing | train | func NewPairing(controller *pair.PairingController, emitter event.Emitter) *Pairing {
endpoint := Pairing{
controller: controller,
emitter: emitter,
}
return &endpoint
} | go | {
"resource": ""
} |
q9226 | NewPairingController | train | func NewPairingController(database db.Database) *PairingController {
c := PairingController{
database: database,
}
return &c
} | go | {
"resource": ""
} |
q9227 | Handle | train | func (c *PairingController) Handle(cont util.Container) (util.Container, error) {
method := PairMethodType(cont.GetByte(TagPairingMethod))
perm := cont.GetByte(TagPermission)
username := cont.GetString(TagUsername)
publicKey := cont.GetBytes(TagPublicKey)
log.Debug.Println("-> Method:", method)
log.Debug.Println("-> Permission:", perm)
log.Debug.Println("-> Username:", username)
log.Debug.Println("-> LTPK:", publicKey)
entity := db.NewEntity(username, publicKey, nil)
out := util.NewTLV8Container()
out.SetByte(TagSequence, 0x2)
switch method {
case PairingMethodDelete:
log.Debug.Printf("Remove LTPK for client '%s'\n", username)
c.database.DeleteEntity(entity)
case PairingMethodAdd:
err := c.database.SaveEntity(entity)
if err != nil {
log.Info.Panic(err)
return nil, err
}
default:
return nil, fmt.Errorf("Invalid pairing method type %v", method)
}
return out, nil
} | go | {
"resource": ""
} |
q9228 | NewTempDatabase | train | func NewTempDatabase() (Database, error) {
storage, err := util.NewTempFileStorage()
return NewDatabaseWithStorage(storage), err
} | go | {
"resource": ""
} |
q9229 | NewDatabase | train | func NewDatabase(path string) (Database, error) {
storage, err := util.NewFileStorage(path)
if err != nil {
return nil, err
}
return NewDatabaseWithStorage(storage), nil
} | go | {
"resource": ""
} |
q9230 | NewDatabaseWithStorage | train | func NewDatabaseWithStorage(storage util.Storage) Database {
c := database{storage: storage}
return &c
} | go | {
"resource": ""
} |
q9231 | EntityWithName | train | func (db *database) EntityWithName(name string) (e Entity, err error) {
return db.entityForKey(toEntityKey(name))
} | go | {
"resource": ""
} |
q9232 | NewResource | train | func NewResource(context hap.Context, imgFn GetImageFunc) *Resource {
r := Resource{
context: context,
imgFn: imgFn,
}
return &r
} | go | {
"resource": ""
} |
q9233 | NewRandomEntityWithName | train | func NewRandomEntityWithName(name string) (e Entity, err error) {
var public []byte
var private []byte
public, private, err = generateKeyPairs()
if err == nil && len(public) > 0 && len(private) > 0 {
e = NewEntity(name, public, private)
}
return
} | go | {
"resource": ""
} |
q9234 | NewEntity | train | func NewEntity(name string, publicKey, privateKey []byte) Entity {
return Entity{Name: name, PublicKey: publicKey, PrivateKey: privateKey}
} | go | {
"resource": ""
} |
q9235 | generateKeyPairs | train | func generateKeyPairs() ([]byte, []byte, error) {
str := util.RandomHexString()
public, private, err := crypto.ED25519GenerateKey(str)
return public, private, err
} | go | {
"resource": ""
} |
q9236 | NewVerifySession | train | func NewVerifySession() *VerifySession {
privateKey := curve25519.GeneratePrivateKey()
publicKey := curve25519.PublicKey(privateKey)
return &VerifySession{
PublicKey: publicKey,
PrivateKey: privateKey,
}
} | go | {
"resource": ""
} |
q9237 | GenerateSharedKeyWithOtherPublicKey | train | func (s *VerifySession) GenerateSharedKeyWithOtherPublicKey(otherPublicKey [32]byte) {
sharedKey := curve25519.SharedSecret(s.PrivateKey, otherPublicKey)
s.OtherPublicKey = otherPublicKey
s.SharedKey = sharedKey
} | go | {
"resource": ""
} |
q9238 | SetupEncryptionKey | train | func (s *VerifySession) SetupEncryptionKey(salt []byte, info []byte) error {
hash, err := hkdf.Sha512(s.SharedKey[:], salt, info)
if err == nil {
s.EncryptionKey = hash
}
return err
} | go | {
"resource": ""
} |
q9239 | NewTelevision | train | func NewTelevision(info Info) *Television {
acc := Television{}
acc.Accessory = New(info, TypeTelevision)
acc.Television = service.NewTelevision()
acc.Speaker = service.NewSpeaker()
acc.AddService(acc.Television.Service)
acc.AddService(acc.Speaker.Service)
return &acc
} | go | {
"resource": ""
} |
q9240 | NewVerifyServerController | train | func NewVerifyServerController(database db.Database, context hap.Context) *VerifyServerController {
controller := VerifyServerController{
database: database,
context: context,
session: NewVerifySession(),
step: VerifyStepWaiting,
}
return &controller
} | go | {
"resource": ""
} |
q9241 | Handle | train | func (verify *VerifyServerController) Handle(in util.Container) (util.Container, error) {
var out util.Container
var err error
method := PairMethodType(in.GetByte(TagPairingMethod))
// It is valid that method is not sent
// If method is sent then it must be 0x00
if method != PairingMethodDefault {
return nil, errInvalidPairMethod(method)
}
seq := VerifyStepType(in.GetByte(TagSequence))
switch seq {
case VerifyStepStartRequest:
if verify.step != VerifyStepWaiting {
verify.reset()
return nil, errInvalidInternalVerifyStep(verify.step)
}
out, err = verify.handlePairVerifyStart(in)
case VerifyStepFinishRequest:
if verify.step != VerifyStepStartResponse {
verify.reset()
return nil, errInvalidInternalVerifyStep(verify.step)
}
out, err = verify.handlePairVerifyFinish(in)
default:
return nil, errInvalidVerifyStep(seq)
}
return out, err
} | go | {
"resource": ""
} |
q9242 | NewPairSetup | train | func NewPairSetup(context hap.Context, device hap.SecuredDevice, database db.Database, emitter event.Emitter) *PairSetup {
endpoint := PairSetup{
device: device,
database: database,
context: context,
emitter: emitter,
}
return &endpoint
} | go | {
"resource": ""
} |
q9243 | HandleUpdateCharacteristics | train | func (ctr *CharacteristicController) HandleUpdateCharacteristics(r io.Reader, conn net.Conn) error {
b, err := ioutil.ReadAll(r)
if err != nil {
return err
}
var chars data.Characteristics
err = json.Unmarshal(b, &chars)
if err != nil {
return err
}
log.Debug.Println(string(b))
for _, c := range chars.Characteristics {
characteristic := ctr.GetCharacteristic(c.AccessoryID, c.CharacteristicID)
if characteristic == nil {
log.Info.Printf("Could not find characteristic with aid %d and iid %d\n", c.AccessoryID, c.CharacteristicID)
continue
}
if c.Value != nil {
characteristic.UpdateValueFromConnection(c.Value, conn)
}
if events, ok := c.Events.(bool); ok == true {
characteristic.SetEventsEnabled(events)
}
}
return err
} | go | {
"resource": ""
} |
q9244 | GetCharacteristic | train | func (ctr *CharacteristicController) GetCharacteristic(aid int64, iid int64) *characteristic.Characteristic {
for _, a := range ctr.container.Accessories {
if a.GetID() == aid {
for _, s := range a.GetServices() {
for _, c := range s.GetCharacteristics() {
if c.GetID() == iid {
return c
}
}
}
}
}
return nil
} | go | {
"resource": ""
} |
q9245 | NewThermostat | train | func NewThermostat(info Info, temp, min, max, steps float64) *Thermostat {
acc := Thermostat{}
acc.Accessory = New(info, TypeThermostat)
acc.Thermostat = service.NewThermostat()
acc.Thermostat.CurrentTemperature.SetValue(temp)
acc.Thermostat.CurrentTemperature.SetMinValue(min)
acc.Thermostat.CurrentTemperature.SetMaxValue(max)
acc.Thermostat.CurrentTemperature.SetStepValue(steps)
acc.Thermostat.TargetTemperature.SetValue(temp)
acc.Thermostat.TargetTemperature.SetMinValue(min)
acc.Thermostat.TargetTemperature.SetMaxValue(max)
acc.Thermostat.TargetTemperature.SetStepValue(steps)
acc.AddService(acc.Thermostat.Service)
return &acc
} | go | {
"resource": ""
} |
q9246 | NewServer | train | func NewServer(c Config) *Server {
// os gives us a free Port when Port is ""
ln, err := net.Listen("tcp", c.Port)
if err != nil {
log.Info.Panic(err)
}
_, port, _ := net.SplitHostPort(ln.Addr().String())
s := Server{
context: c.Context,
database: c.Database,
container: c.Container,
device: c.Device,
Mux: http.NewServeMux(),
mutex: c.Mutex,
listener: ln.(*net.TCPListener),
port: port,
emitter: c.Emitter,
}
s.setupEndpoints()
return &s
} | go | {
"resource": ""
} |
q9247 | listenAndServe | train | func (s *Server) listenAndServe(addr string, handler http.Handler, context hap.Context) error {
server := http.Server{Addr: addr, Handler: handler}
// Use a TCPListener
listener := hap.NewTCPListener(s.listener, context)
s.hapListener = listener
return server.Serve(listener)
} | go | {
"resource": ""
} |
q9248 | setupEndpoints | train | func (s *Server) setupEndpoints() {
containerController := controller.NewContainerController(s.container)
characteristicsController := controller.NewCharacteristicController(s.container)
pairingController := pair.NewPairingController(s.database)
s.Mux.Handle("/pair-setup", endpoint.NewPairSetup(s.context, s.device, s.database, s.emitter))
s.Mux.Handle("/pair-verify", endpoint.NewPairVerify(s.context, s.database))
s.Mux.Handle("/accessories", endpoint.NewAccessories(containerController, s.mutex))
s.Mux.Handle("/characteristics", endpoint.NewCharacteristics(s.context, characteristicsController, s.mutex))
s.Mux.Handle("/pairings", endpoint.NewPairing(pairingController, s.emitter))
s.Mux.Handle("/identify", endpoint.NewIdentify(containerController))
} | go | {
"resource": ""
} |
q9249 | ValidateED25519Signature | train | func ValidateED25519Signature(key, data, signature []byte) bool {
if len(key) != ed25519.PublicKeySize || len(signature) != ed25519.SignatureSize {
return false
}
var k [ed25519.PublicKeySize]byte
var s [ed25519.SignatureSize]byte
copy(k[:], key)
copy(s[:], signature)
return ed25519.Verify(&k, data, &s)
} | go | {
"resource": ""
} |
q9250 | ED25519Signature | train | func ED25519Signature(key, data []byte) ([]byte, error) {
if len(key) != ed25519.PrivateKeySize {
return nil, fmt.Errorf("Invalid size of key (%v)", len(key))
}
var k [ed25519.PrivateKeySize]byte
copy(k[:], key)
signature := ed25519.Sign(&k, data)
return signature[:], nil
} | go | {
"resource": ""
} |
q9251 | ED25519GenerateKey | train | func ED25519GenerateKey(str string) ([]byte /* public */, []byte /* private */, error) {
b := bytes.NewBuffer([]byte(str))
if len(str) < 32 {
zeros := make([]byte, 32-len(str))
b.Write(zeros)
}
public, private, err := ed25519.GenerateKey(bytes.NewReader(b.Bytes()))
return public[:], private[:], err
} | go | {
"resource": ""
} |
q9252 | CharacteristicLocalFilePath | train | func CharacteristicLocalFilePath(char *gen.CharacteristicMetadata) string {
return filepath.Join(CharacteristicLocalDir, CharacteristicFileName(char))
} | go | {
"resource": ""
} |
q9253 | CharacteristicRelativeFilePath | train | func CharacteristicRelativeFilePath(char *gen.CharacteristicMetadata) string {
return filepath.Join(CharacteristicDir, CharacteristicFileName(char))
} | go | {
"resource": ""
} |
q9254 | ServiceLocalFilePath | train | func ServiceLocalFilePath(sv *gen.ServiceMetadata) string {
return filepath.Join(ServiceLocalDir, ServiceFileName(sv))
} | go | {
"resource": ""
} |
q9255 | ServiceRelativeFilePath | train | func ServiceRelativeFilePath(sv *gen.ServiceMetadata) string {
return filepath.Join(ServiceDir, ServiceFileName(sv))
} | go | {
"resource": ""
} |
q9256 | NewTCPListener | train | func NewTCPListener(l *net.TCPListener, context Context) *TCPListener {
return &TCPListener{l, context}
} | go | {
"resource": ""
} |
q9257 | Accept | train | func (l *TCPListener) Accept() (c net.Conn, err error) {
conn, err := l.AcceptTCP()
if err != nil {
return
}
// TODO(brutella) Check if we should use tcp keepalive
// conn.SetKeepAlive(true)
// conn.SetKeepAlivePeriod(3 * time.Minute)
hapConn := NewConnection(conn, l.context)
return hapConn, err
} | go | {
"resource": ""
} |
q9258 | NewCamera | train | func NewCamera(info Info) *Camera {
acc := Camera{}
acc.Accessory = New(info, TypeIPCamera)
acc.Control = service.NewCameraControl()
acc.AddService(acc.Control.Service)
// TODO (mah) a camera must support at least 2 rtp streams
acc.StreamManagement1 = service.NewCameraRTPStreamManagement()
acc.StreamManagement2 = service.NewCameraRTPStreamManagement()
acc.AddService(acc.StreamManagement1.Service)
// acc.AddService(acc.StreamManagement2.Service)
return &acc
} | go | {
"resource": ""
} |
q9259 | RandomHexString | train | func RandomHexString() string {
var b [16]byte
// Read might block
// > crypto/rand: blocked for 60 seconds waiting to read random data from the kernel
// > https://github.com/golang/go/commit/1961d8d72a53e780effa18bfa8dbe4e4282df0b2
_, err := rand.Read(b[:])
if err != nil {
panic(err)
}
var out [32]byte
for i := 0; i < len(b); i++ {
out[i*2] = btoh((b[i] >> 4) & 0xF)
out[i*2+1] = btoh(b[i] & 0xF)
}
return string(out[:])
} | go | {
"resource": ""
} |
q9260 | NewConnection | train | func NewConnection(connection net.Conn, context Context) *Connection {
conn := &Connection{
connection: connection,
context: context,
}
// Setup new session for the connection
session := NewSession(conn)
context.SetSessionForConnection(session, conn)
return conn
} | go | {
"resource": ""
} |
q9261 | EncryptedWrite | train | func (con *Connection) EncryptedWrite(b []byte) (int, error) {
var buffer bytes.Buffer
buffer.Write(b)
encrypted, err := con.getEncrypter().Encrypt(&buffer)
if err != nil {
log.Info.Panic("Encryption failed:", err)
err = con.connection.Close()
return 0, err
}
encryptedBytes, err := ioutil.ReadAll(encrypted)
n, err := con.connection.Write(encryptedBytes)
return n, err
} | go | {
"resource": ""
} |
q9262 | DecryptedRead | train | func (con *Connection) DecryptedRead(b []byte) (int, error) {
if con.readBuffer == nil {
buffered := bufio.NewReader(con.connection)
decrypted, err := con.getDecrypter().Decrypt(buffered)
if err != nil {
if neterr, ok := err.(net.Error); ok && neterr.Timeout() {
// Ignore timeout error #77
} else {
log.Debug.Println("Decryption failed:", err)
err = con.connection.Close()
}
return 0, err
}
con.readBuffer = decrypted
}
n, err := con.readBuffer.Read(b)
if n < len(b) || err == io.EOF {
con.readBuffer = nil
}
return n, err
} | go | {
"resource": ""
} |
q9263 | Write | train | func (con *Connection) Write(b []byte) (int, error) {
if con.getEncrypter() != nil {
return con.EncryptedWrite(b)
}
return con.connection.Write(b)
} | go | {
"resource": ""
} |
q9264 | Read | train | func (con *Connection) Read(b []byte) (int, error) {
if con.getDecrypter() != nil {
return con.DecryptedRead(b)
}
return con.connection.Read(b)
} | go | {
"resource": ""
} |
q9265 | Close | train | func (con *Connection) Close() error {
log.Debug.Println("Close connection and remove session")
// Remove session from the context
con.context.DeleteSessionForConnection(con.connection)
return con.connection.Close()
} | go | {
"resource": ""
} |
q9266 | getEncrypter | train | func (con *Connection) getEncrypter() crypto.Encrypter {
session := con.context.GetSessionForConnection(con.connection)
if session != nil {
return session.Encrypter()
}
return nil
} | go | {
"resource": ""
} |
q9267 | getDecrypter | train | func (con *Connection) getDecrypter() crypto.Decrypter {
session := con.context.GetSessionForConnection(con.connection)
if session != nil {
return session.Decrypter()
}
return nil
} | go | {
"resource": ""
} |
q9268 | NewDevice | train | func NewDevice(name string, database db.Database) (Device, error) {
var e db.Entity
var err error
if e, err = database.EntityWithName(name); err != nil {
if e, err = db.NewRandomEntityWithName(name); err == nil {
err = database.SaveEntity(e)
}
}
return &device{e}, err
} | go | {
"resource": ""
} |
q9269 | CharacteristicGoCode | train | func CharacteristicGoCode(char *gen.CharacteristicMetadata) ([]byte, error) {
var err error
var buf bytes.Buffer
data := NewCharacteristic(char)
t := template.New("Test Template")
t, err = t.Parse(CharStructTemplate)
t.Execute(&buf, data)
return buf.Bytes(), err
} | go | {
"resource": ""
} |
q9270 | isReadable | train | func isReadable(char *gen.CharacteristicMetadata) bool {
for _, perm := range char.Properties {
if perm == "read" {
return true
}
}
return false
} | go | {
"resource": ""
} |
q9271 | minifyUUID | train | func minifyUUID(s string) string {
authRegexp := regexp.MustCompile(`^([0-9a-fA-F]*)`)
if str := authRegexp.FindString(s); len(str) > 0 {
return strings.TrimLeft(str, "0")
}
return s
} | go | {
"resource": ""
} |
q9272 | NewSwitch | train | func NewSwitch(info Info) *Switch {
acc := Switch{}
acc.Accessory = New(info, TypeSwitch)
acc.Switch = service.NewSwitch()
acc.AddService(acc.Switch.Service)
return &acc
} | go | {
"resource": ""
} |
q9273 | NewSetupClientSession | train | func NewSetupClientSession(username string, pin string) *SetupClientSession {
rp, _ := srp.NewSRP(SRPGroup, sha512.New, KeyDerivativeFuncRFC2945(sha512.New, []byte(username)))
client := rp.NewClientSession([]byte(username), []byte(pin))
hap := SetupClientSession{
session: client,
}
return &hap
} | go | {
"resource": ""
} |
q9274 | GenerateKeys | train | func (s *SetupClientSession) GenerateKeys(salt []byte, otherPublicKey []byte) error {
privateKey, err := s.session.ComputeKey(salt, otherPublicKey)
if err == nil {
s.PublicKey = s.session.GetA()
s.PrivateKey = privateKey
s.Proof = s.session.ComputeAuthenticator()
}
return err
} | go | {
"resource": ""
} |
q9275 | IsServerProofValid | train | func (s *SetupClientSession) IsServerProofValid(proof []byte) bool {
return s.session.VerifyServerAuthenticator(proof)
} | go | {
"resource": ""
} |
q9276 | SetupEncryptionKey | train | func (s *SetupClientSession) SetupEncryptionKey(salt []byte, info []byte) error {
hash, err := hkdf.Sha512(s.PrivateKey, salt, info)
if err == nil {
s.EncryptionKey = hash
}
return err
} | go | {
"resource": ""
} |
q9277 | NewChunkedWriter | train | func NewChunkedWriter(wr io.Writer, chunk int) io.Writer {
return &chunkedWriter{wr, chunk}
} | go | {
"resource": ""
} |
q9278 | NewCharacteristics | train | func NewCharacteristics(context hap.Context, c hap.CharacteristicsHandler, mutex *sync.Mutex) *Characteristics {
handler := Characteristics{
controller: c,
mutex: mutex,
context: context,
}
return &handler
} | go | {
"resource": ""
} |
q9279 | txtRecords | train | func (cfg Config) txtRecords() map[string]string {
return map[string]string{
"pv": cfg.protocol,
"id": cfg.id,
"c#": fmt.Sprintf("%d", cfg.version),
"s#": fmt.Sprintf("%d", cfg.state),
"sf": fmt.Sprintf("%d", to.Int64(cfg.discoverable)),
"ff": fmt.Sprintf("%d", to.Int64(cfg.mfiCompliant)),
"md": cfg.name,
"ci": fmt.Sprintf("%d", cfg.categoryId),
}
} | go | {
"resource": ""
} |
q9280 | load | train | func (cfg *Config) load(storage util.Storage) {
if b, err := storage.Get("uuid"); err == nil && len(b) > 0 {
cfg.id = string(b)
}
if b, err := storage.Get("version"); err == nil && len(b) > 0 {
cfg.version = to.Int64(string(b))
}
if b, err := storage.Get("configHash"); err == nil && len(b) > 0 {
cfg.configHash = b
}
} | go | {
"resource": ""
} |
q9281 | save | train | func (cfg *Config) save(storage util.Storage) {
storage.Set("uuid", []byte(cfg.id))
storage.Set("version", []byte(fmt.Sprintf("%d", cfg.version)))
storage.Set("configHash", []byte(cfg.configHash))
} | go | {
"resource": ""
} |
q9282 | merge | train | func (cfg *Config) merge(other Config) {
if dir := other.StoragePath; len(dir) > 0 {
cfg.StoragePath = dir
}
if pin := other.Pin; len(pin) > 0 {
cfg.Pin = pin
}
if port := other.Port; len(port) > 0 {
cfg.Port = ":" + port
}
if ip := other.IP; len(ip) > 0 {
cfg.IP = ip
}
} | go | {
"resource": ""
} |
q9283 | updateConfigHash | train | func (cfg *Config) updateConfigHash(hash []byte) {
if cfg.configHash != nil && reflect.DeepEqual(hash, cfg.configHash) == false {
cfg.version += 1
}
cfg.configHash = hash
} | go | {
"resource": ""
} |
q9284 | NewTempFileStorage | train | func NewTempFileStorage() (Storage, error) {
dir := RandomHexString()
return NewFileStorage(path.Join(os.TempDir(), dir))
} | go | {
"resource": ""
} |
q9285 | NewFileStorage | train | func NewFileStorage(dir string) (Storage, error) {
path, err := filepath.Abs(dir)
if err != nil {
return nil, err
}
// Why 0777?
// Read http://unix.stackexchange.com/questions/21251/why-do-directories-need-the-executable-x-permission-to-be-opened
err = os.MkdirAll(path, 0777)
return &fileStorage{dirPath: path}, err
} | go | {
"resource": ""
} |
q9286 | Set | train | func (f *fileStorage) Set(key string, value []byte) error {
file, err := f.fileForWrite(key)
if err != nil {
return err
}
defer file.Close()
_, err = file.Write(value)
return err
} | go | {
"resource": ""
} |
q9287 | Get | train | func (f *fileStorage) Get(key string) ([]byte, error) {
file, err := f.fileForRead(key)
if err != nil {
return nil, err
}
defer file.Close()
var b bytes.Buffer
var buffer = make([]byte, 32)
for {
n, _ := file.Read(buffer)
if n > 0 {
b.Write(buffer[:n])
} else {
break
}
}
return b.Bytes(), nil
} | go | {
"resource": ""
} |
q9288 | Delete | train | func (f *fileStorage) Delete(key string) error {
return os.Remove(f.filePathToFile(key))
} | go | {
"resource": ""
} |
q9289 | NewSetupServerSession | train | func NewSetupServerSession(username, pin string) (*SetupServerSession, error) {
var err error
pairName := []byte("Pair-Setup")
srp, err := srp.NewSRP(SRPGroup, sha512.New, KeyDerivativeFuncRFC2945(sha512.New, []byte(pairName)))
if err == nil {
srp.SaltLength = 16
salt, v, err := srp.ComputeVerifier([]byte(pin))
if err == nil {
session := srp.NewServerSession([]byte(pairName), salt, v)
pairing := SetupServerSession{
session: session,
Salt: salt,
PublicKey: session.GetB(),
Username: []byte(username),
}
return &pairing, nil
}
}
return nil, err
} | go | {
"resource": ""
} |
q9290 | SetupPrivateKeyFromClientPublicKey | train | func (p *SetupServerSession) SetupPrivateKeyFromClientPublicKey(key []byte) error {
key, err := p.session.ComputeKey(key) // S
if err == nil {
p.PrivateKey = key
}
return err
} | go | {
"resource": ""
} |
q9291 | SetupEncryptionKey | train | func (p *SetupServerSession) SetupEncryptionKey(salt []byte, info []byte) error {
hash, err := hkdf.Sha512(p.PrivateKey, salt, info)
if err == nil {
p.EncryptionKey = hash
}
return err
} | go | {
"resource": ""
} |
q9292 | Run | train | func (p *ProtoCommand) Run(systemUnderTest SystemUnderTest) Result {
if p.RunFunc != nil {
return p.RunFunc(systemUnderTest)
}
return nil
} | go | {
"resource": ""
} |
q9293 | NextState | train | func (p *ProtoCommand) NextState(state State) State {
if p.NextStateFunc != nil {
return p.NextStateFunc(state)
}
return state
} | go | {
"resource": ""
} |
q9294 | PreCondition | train | func (p *ProtoCommand) PreCondition(state State) bool {
if p.PreConditionFunc != nil {
return p.PreConditionFunc(state)
}
return true
} | go | {
"resource": ""
} |
q9295 | PostCondition | train | func (p *ProtoCommand) PostCondition(state State, result Result) *gopter.PropResult {
if p.PostConditionFunc != nil {
return p.PostConditionFunc(state, result)
}
return &gopter.PropResult{Status: gopter.PropTrue}
} | go | {
"resource": ""
} |
q9296 | TimeRange | train | func TimeRange(from time.Time, duration time.Duration) gopter.Gen {
return func(genParams *gopter.GenParameters) *gopter.GenResult {
v := from.Add(time.Duration(genParams.Rng.Int63n(int64(duration))))
return gopter.NewGenResult(v, TimeShrinker)
}
} | go | {
"resource": ""
} |
q9297 | Complex128Shrinker | train | func Complex128Shrinker(v interface{}) gopter.Shrink {
c := v.(complex128)
realShrink := Float64Shrinker(real(c)).Map(func(r float64) complex128 {
return complex(r, imag(c))
})
imagShrink := Float64Shrinker(imag(c)).Map(func(i float64) complex128 {
return complex(real(c), i)
})
return realShrink.Interleave(imagShrink)
} | go | {
"resource": ""
} |
q9298 | Complex64Shrinker | train | func Complex64Shrinker(v interface{}) gopter.Shrink {
c := v.(complex64)
realShrink := Float64Shrinker(float64(real(c))).Map(func(r float64) complex64 {
return complex(float32(r), imag(c))
})
imagShrink := Float64Shrinker(float64(imag(c))).Map(func(i float64) complex64 {
return complex(real(c), float32(i))
})
return realShrink.Interleave(imagShrink)
} | go | {
"resource": ""
} |
q9299 | WithSize | train | func (p *GenParameters) WithSize(size int) *GenParameters {
newParameters := *p
newParameters.MaxSize = size
return &newParameters
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.