id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c9200 | (SecuredDevice, error) {
d, err := NewDevice(name, database)
return &securedDevice{d, pin}, err
} | |
c9201 |
m.Accessories = append(m.Accessories, a)
} | |
c9202 |
m.Accessories = append(m.Accessories[:i], m.Accessories[i+1:]...)
}
}
} | |
c9203 | m.Accessories {
if a.Equal(container.Accessories[i]) == false {
return false
}
}
return true
}
return false
} | |
c9204 | > 0 {
if len(as) > 1 {
return TypeBridge
}
return as[0].Type
}
return TypeOther
} | |
c9205 | return nil, err
}
controller := SetupServerController{
device: device,
session: session,
database: database,
step: PairStepWaiting,
}
return &controller, nil
} | |
c9206 | context,
database: database,
}
return &endpoint
} | |
c9207 | err := json.Marshal(ctr.container)
return bytes.NewBuffer(result), err
} | |
c9208 | }
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) {
... | |
c9209 | a.Services = append(a.Services, s)
} | |
c9210 | := range s.Characteristics {
c.SetID(a.idCount)
a.idCount++
}
}
} | |
c9211 | {
if s.Equal(accessory.Services[i]) == false {
return false
}
}
return a.ID == accessory.ID
}
return false
} | |
c9212 | more than one entity.
if es, err := t.database.Entities(); err == nil && len(es) > 1 {
return true
}
return false
} | |
c9213 |
log.Debug.Printf("Event: unpaired with device")
t.updateMDNSReachability()
default:
break
}
} | |
c9214 |
acc.Lightbulb.Brightness.SetValue(100)
acc.AddService(acc.Lightbulb.Service)
return &acc
} | |
c9215 | signal.Notify(c, os.Kill)
signal.Notify(c, syscall.SIGTERM)
go func() {
select {
case <-c:
if fn != nil {
fn()
}
}
}()
} | |
c9216 | append(c, toHex(result[4]))
c = append(c, toHex(result[5]))
return strings.ToUpper(strings.Join(c, ":"))
} | |
c9217 |
if err != nil {
return nil, err
}
return NewNotification(body), nil
} | |
c9218 | 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 res... | |
c9219 | err := json.Marshal(chars)
if err != nil {
return nil, err
}
var b bytes.Buffer
b.Write(result)
return &b, err
} | |
c9220 | info)
key := make([]byte, 32) // 256 bit
_, err := io.ReadFull(hkdf, key)
var result [32]byte
copy(result[:], key)
return result, err
} | |
c9221 | {
handler := Accessories{
controller: c,
mutex: mutex,
}
return &handler
} | |
c9222 | 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
} | |
c9223 | {
s := session{
connection: connection,
}
return &s
} | |
c9224 |
acc.Outlet.OutletInUse.SetValue(true)
acc.AddService(acc.Outlet.Service)
return &acc
} | |
c9225 | controller,
emitter: emitter,
}
return &endpoint
} | |
c9226 | PairingController{
database: database,
}
return &c
} | |
c9227 | 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... | |
c9228 | return NewDatabaseWithStorage(storage), err
} | |
c9229 | nil, err
}
return NewDatabaseWithStorage(storage), nil
} | |
c9230 | := database{storage: storage}
return &c
} | |
c9231 | (e Entity, err error) {
return db.entityForKey(toEntityKey(name))
} | |
c9232 | context,
imgFn: imgFn,
}
return &r
} | |
c9233 | err == nil && len(public) > 0 && len(private) > 0 {
e = NewEntity(name, public, private)
}
return
} | |
c9234 | Entity{Name: name, PublicKey: publicKey, PrivateKey: privateKey}
} | |
c9235 | := crypto.ED25519GenerateKey(str)
return public, private, err
} | |
c9236 |
publicKey := curve25519.PublicKey(privateKey)
return &VerifySession{
PublicKey: publicKey,
PrivateKey: privateKey,
}
} | |
c9237 | otherPublicKey)
s.OtherPublicKey = otherPublicKey
s.SharedKey = sharedKey
} | |
c9238 |
hash, err := hkdf.Sha512(s.SharedKey[:], salt, info)
if err == nil {
s.EncryptionKey = hash
}
return err
} | |
c9239 | = service.NewTelevision()
acc.Speaker = service.NewSpeaker()
acc.AddService(acc.Television.Service)
acc.AddService(acc.Speaker.Service)
return &acc
} | |
c9240 | context,
session: NewVerifySession(),
step: VerifyStepWaiting,
}
return &controller
} | |
c9241 |
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
} | |
c9242 | device,
database: database,
context: context,
emitter: emitter,
}
return &endpoint
} | |
c9243 | 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... | |
c9244 |
for _, c := range s.GetCharacteristics() {
if c.GetID() == iid {
return c
}
}
}
}
}
return nil
} | |
c9245 |
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.... | |
c9246 | http.NewServeMux(),
mutex: c.Mutex,
listener: ln.(*net.TCPListener),
port: port,
emitter: c.Emitter,
}
s.setupEndpoints()
return &s
} | |
c9247 | listener := hap.NewTCPListener(s.listener, context)
s.hapListener = listener
return server.Serve(listener)
} | |
c9248 | 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))
} | |
c9249 |
return false
}
var k [ed25519.PublicKeySize]byte
var s [ed25519.SignatureSize]byte
copy(k[:], key)
copy(s[:], signature)
return ed25519.Verify(&k, data, &s)
} | |
c9250 | var k [ed25519.PrivateKeySize]byte
copy(k[:], key)
signature := ed25519.Sign(&k, data)
return signature[:], nil
} | |
c9251 | public, private, err := ed25519.GenerateKey(bytes.NewReader(b.Bytes()))
return public[:], private[:], err
} | |
c9252 | filepath.Join(CharacteristicLocalDir, CharacteristicFileName(char))
} | |
c9253 | filepath.Join(CharacteristicDir, CharacteristicFileName(char))
} | |
c9254 | filepath.Join(ServiceLocalDir, ServiceFileName(sv))
} | |
c9255 | filepath.Join(ServiceDir, ServiceFileName(sv))
} | |
c9256 | return &TCPListener{l, context}
} | |
c9257 | conn.SetKeepAlive(true)
// conn.SetKeepAlivePeriod(3 * time.Minute)
hapConn := NewConnection(conn, l.context)
return hapConn, err
} | |
c9258 | 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
} | |
c9259 | 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[:])
} | |
c9260 |
session := NewSession(conn)
context.SetSessionForConnection(session, conn)
return conn
} | |
c9261 | return 0, err
}
encryptedBytes, err := ioutil.ReadAll(encrypted)
n, err := con.connection.Write(encryptedBytes)
return n, err
} | |
c9262 | && 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
... | |
c9263 | return con.EncryptedWrite(b)
}
return con.connection.Write(b)
} | |
c9264 | return con.DecryptedRead(b)
}
return con.connection.Read(b)
} | |
c9265 | con.context.DeleteSessionForConnection(con.connection)
return con.connection.Close()
} | |
c9266 | session != nil {
return session.Encrypter()
}
return nil
} | |
c9267 | session != nil {
return session.Decrypter()
}
return nil
} | |
c9268 | err = db.NewRandomEntityWithName(name); err == nil {
err = database.SaveEntity(e)
}
}
return &device{e}, err
} | |
c9269 | template.New("Test Template")
t, err = t.Parse(CharStructTemplate)
t.Execute(&buf, data)
return buf.Bytes(), err
} | |
c9270 | == "read" {
return true
}
}
return false
} | |
c9271 | authRegexp.FindString(s); len(str) > 0 {
return strings.TrimLeft(str, "0")
}
return s
} | |
c9272 | service.NewSwitch()
acc.AddService(acc.Switch.Service)
return &acc
} | |
c9273 | := rp.NewClientSession([]byte(username), []byte(pin))
hap := SetupClientSession{
session: client,
}
return &hap
} | |
c9274 | s.PublicKey = s.session.GetA()
s.PrivateKey = privateKey
s.Proof = s.session.ComputeAuthenticator()
}
return err
} | |
c9275 | return s.session.VerifyServerAuthenticator(proof)
} | |
c9276 | if err == nil {
s.EncryptionKey = hash
}
return err
} | |
c9277 | return &chunkedWriter{wr, chunk}
} | |
c9278 | c,
mutex: mutex,
context: context,
}
return &handler
} | |
c9279 | to.Int64(cfg.discoverable)),
"ff": fmt.Sprintf("%d", to.Int64(cfg.mfiCompliant)),
"md": cfg.name,
"ci": fmt.Sprintf("%d", cfg.categoryId),
}
} | |
c9280 | = to.Int64(string(b))
}
if b, err := storage.Get("configHash"); err == nil && len(b) > 0 {
cfg.configHash = b
}
} | |
c9281 |
storage.Set("version", []byte(fmt.Sprintf("%d", cfg.version)))
storage.Set("configHash", []byte(cfg.configHash))
} | |
c9282 | := other.Port; len(port) > 0 {
cfg.Port = ":" + port
}
if ip := other.IP; len(ip) > 0 {
cfg.IP = ip
}
} | |
c9283 | == false {
cfg.version += 1
}
cfg.configHash = hash
} | |
c9284 | RandomHexString()
return NewFileStorage(path.Join(os.TempDir(), dir))
} | |
c9285 |
// 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
} | |
c9286 |
if err != nil {
return err
}
defer file.Close()
_, err = file.Write(value)
return err
} | |
c9287 | n, _ := file.Read(buffer)
if n > 0 {
b.Write(buffer[:n])
} else {
break
}
}
return b.Bytes(), nil
} | |
c9288 | os.Remove(f.filePathToFile(key))
} | |
c9289 |
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... | |
c9290 |
if err == nil {
p.PrivateKey = key
}
return err
} | |
c9291 | if err == nil {
p.EncryptionKey = hash
}
return err
} | |
c9292 | return p.RunFunc(systemUnderTest)
}
return nil
} | |
c9293 | p.NextStateFunc(state)
}
return state
} | |
c9294 | if p.PreConditionFunc != nil {
return p.PreConditionFunc(state)
}
return true
} | |
c9295 | p.PostConditionFunc != nil {
return p.PostConditionFunc(state, result)
}
return &gopter.PropResult{Status: gopter.PropTrue}
} | |
c9296 | v := from.Add(time.Duration(genParams.Rng.Int63n(int64(duration))))
return gopter.NewGenResult(v, TimeShrinker)
}
} | |
c9297 |
imagShrink := Float64Shrinker(imag(c)).Map(func(i float64) complex128 {
return complex(real(c), i)
})
return realShrink.Interleave(imagShrink)
} | |
c9298 | imagShrink := Float64Shrinker(float64(imag(c))).Map(func(i float64) complex64 {
return complex(real(c), float32(i))
})
return realShrink.Interleave(imagShrink)
} | |
c9299 | *p
newParameters.MaxSize = size
return &newParameters
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.