func (u *User) RevokeKeysProof(key GenericKey, kidsToRevoke []keybase1.KID, deviceToDisable keybase1.DeviceID) (*jsonw.Wrapper, error) {
ret, err := ProofMetadata{
Me: u,
LinkType: RevokeType,
SigningKey: key,
}.ToJSON(u.G())
if err != nil {
return nil, err
}
body := ret.AtKey("body")
revokeSection := jsonw.NewDictionary()
revokeSection.SetKey("kids", jsonw.NewWrapper(kidsToRevoke))
body.SetKey("revoke", revokeSection)
if deviceToDisable.Exists() {
device, err := u.GetDevice(deviceToDisable)
if err != nil {
return nil, err
}
deviceSection := jsonw.NewDictionary()
deviceSection.SetKey("id", jsonw.NewString(deviceToDisable.String()))
deviceSection.SetKey("type", jsonw.NewString(device.Type))
deviceSection.SetKey("status", jsonw.NewInt(DeviceStatusDefunct))
body.SetKey("device", deviceSection)
}
return ret, nil
}
func (f *JSONFile) Load(warnOnNotFound bool) error {
f.G().Log.Debug("+ loading %s file: %s", f.which, f.filename)
file, err := os.Open(f.filename)
if err != nil {
if os.IsNotExist(err) {
msg := fmt.Sprintf("No %s file found; tried %s", f.which, f.filename)
if warnOnNotFound {
f.G().Log.Warning(msg)
} else {
f.G().Log.Debug(msg)
}
return nil
} else if os.IsPermission(err) {
f.G().Log.Warning("Permission denied opening %s file %s", f.which, f.filename)
return nil
} else {
return err
}
}
f.exists = true
defer file.Close()
decoder := json.NewDecoder(file)
obj := make(map[string]interface{})
// Treat empty files like an empty dictionary
if err = decoder.Decode(&obj); err != nil && err != io.EOF {
f.G().Log.Errorf("Error decoding %s file %s", f.which, f.filename)
return err
}
f.jw = jsonw.NewWrapper(obj)
f.G().Log.Debug("- successfully loaded %s file", f.which)
return nil
}
//============================================================================
// Shared code
//
func doRequestShared(api Requester, arg APIArg, req *http.Request, wantJSONRes bool) (
resp *http.Response, jw *jsonw.Wrapper, err error) {
api.fixHeaders(arg, req)
cli := api.getCli(arg.NeedSession)
// Actually send the request via Go's libraries
timerType := TimerAPI
if api.isExternal() {
timerType = TimerXAPI
}
if G.Env.GetAPIDump() {
jpStr, _ := json.MarshalIndent(arg.JSONPayload, "", " ")
argStr, _ := json.MarshalIndent(arg.getHTTPArgs(), "", " ")
G.Log.Debug(fmt.Sprintf("| full request: json:%s querystring:%s", jpStr, argStr))
}
timer := G.Timers.Start(timerType)
resp, err = cli.cli.Do(req)
timer.Report(req.Method + " " + arg.Endpoint)
if err != nil {
return nil, nil, APINetError{err: err}
}
G.Log.Debug(fmt.Sprintf("| Result is: %s", resp.Status))
// Check for a code 200 or rather which codes were allowed in arg.HttpStatus
err = checkHTTPStatus(arg, resp)
if err != nil {
return nil, nil, err
}
err = api.consumeHeaders(resp)
if err != nil {
return nil, nil, err
}
if wantJSONRes {
decoder := json.NewDecoder(resp.Body)
var obj interface{}
decoder.UseNumber()
err = decoder.Decode(&obj)
resp.Body.Close()
if err != nil {
err = fmt.Errorf("Error in parsing JSON reply from server: %s", err)
return nil, nil, err
}
jw = jsonw.NewWrapper(obj)
if G.Env.GetAPIDump() {
b, _ := json.MarshalIndent(obj, "", " ")
G.Log.Debug(fmt.Sprintf("| full reply: %s", b))
}
}
return resp, jw, nil
}
func (f *JSONConfigFile) setValueAtPath(p string, getter valueGetter, v interface{}) error {
existing, err := getter(f.jw.AtPath(p))
if err != nil || existing != v {
err = f.jw.SetValueAtPath(p, jsonw.NewWrapper(v))
if err == nil {
return f.flush()
}
}
return err
}
func (a *APIServerHandler) convertRes(res *libkb.APIRes) keybase1.APIRes {
// Translate the result
var ares keybase1.APIRes
mstatus, err := res.Status.Marshal()
if err == nil {
ares.Status = string(mstatus[:])
}
mbody, err := res.Body.Marshal()
if err == nil {
ares.Body = string(mbody[:])
}
ares.HttpStatus = res.HTTPStatus
appStatus := jsonw.NewWrapper(res.AppStatus)
mappstatus, err := appStatus.Marshal()
if err == nil {
ares.AppStatus = string(mappstatus[:])
}
return ares
}
func (c *ChainLink) Pack() error {
p := jsonw.NewDictionary()
// Store the original JSON string so its order is preserved
p.SetKey("payload_json", jsonw.NewString(c.unpacked.payloadJSONStr))
p.SetKey("sig", jsonw.NewString(c.unpacked.sig))
p.SetKey("sig_id", jsonw.NewString(string(c.unpacked.sigID)))
p.SetKey("kid", c.unpacked.kid.ToJsonw())
p.SetKey("ctime", jsonw.NewInt64(c.unpacked.ctime))
if c.unpacked.pgpFingerprint != nil {
p.SetKey("fingerprint", jsonw.NewString(c.unpacked.pgpFingerprint.String()))
}
p.SetKey("sig_verified", jsonw.NewBool(c.sigVerified))
p.SetKey("proof_text_full", jsonw.NewString(c.unpacked.proofText))
if c.cki != nil {
p.SetKey("computed_key_infos", jsonw.NewWrapper(*c.cki))
}
c.packed = p
return nil
}
func (a *FakeAPI) Get(arg APIArg) (*APIRes, error) {
decoder := json.NewDecoder(bytes.NewBufferString(fakeResponse))
var obj interface{}
decoder.UseNumber()
err := decoder.Decode(&obj)
if err != nil {
err = fmt.Errorf("Error in parsing JSON reply from server: %s", err)
return nil, err
}
jw := jsonw.NewWrapper(obj)
status, err := jw.AtKey("status").ToDictionary()
if err != nil {
err = fmt.Errorf("Cannot parse server's 'status' field: %s", err)
return nil, err
}
body := jw
return &APIRes{status, body, 200, nil}, err
}
// The returned response, if non-nil, should have
// DiscardAndCloseBody() called on it.
func doRequestShared(api Requester, arg APIArg, req *http.Request, wantJSONRes bool) (
_ *http.Response, jw *jsonw.Wrapper, err error) {
if !arg.G().Env.GetTorMode().UseSession() && arg.NeedSession {
err = TorSessionRequiredError{}
return
}
dbg := func(s string) {
arg.G().Log.Debug(fmt.Sprintf("| doRequestShared(%s) for %s", s, arg.Endpoint))
}
dbg("fixHeaders")
api.fixHeaders(arg, req)
dbg("getCli")
cli := api.getCli(arg.NeedSession)
// Actually send the request via Go's libraries
timerType := TimerAPI
if api.isExternal() {
timerType = TimerXAPI
}
if arg.G().Env.GetAPIDump() {
jpStr, _ := json.MarshalIndent(arg.JSONPayload, "", " ")
argStr, _ := json.MarshalIndent(arg.getHTTPArgs(), "", " ")
arg.G().Log.Debug(fmt.Sprintf("| full request: json:%s querystring:%s", jpStr, argStr))
}
timer := arg.G().Timers.Start(timerType)
dbg("Do")
internalResp, err := doRetry(arg, cli, req)
dbg("Done")
defer func() {
if internalResp != nil && err != nil {
DiscardAndCloseBody(internalResp)
}
}()
timer.Report(req.Method + " " + arg.Endpoint)
if err != nil {
return nil, nil, APINetError{err: err}
}
arg.G().Log.Debug(fmt.Sprintf("| Result is: %s", internalResp.Status))
// The server sends "client version out of date" messages through the API
// headers. If the client is *really* out of date, the request status will
// be a 400 error, but these headers will still be present. So we need to
// handle headers *before* we abort based on status below.
err = api.consumeHeaders(internalResp)
if err != nil {
return nil, nil, err
}
// Check for a code 200 or rather which codes were allowed in arg.HttpStatus
err = checkHTTPStatus(arg, internalResp)
if err != nil {
return nil, nil, err
}
if wantJSONRes {
decoder := json.NewDecoder(internalResp.Body)
var obj interface{}
decoder.UseNumber()
err = decoder.Decode(&obj)
if err != nil {
err = fmt.Errorf("Error in parsing JSON reply from server: %s", err)
return nil, nil, err
}
jw = jsonw.NewWrapper(obj)
if arg.G().Env.GetAPIDump() {
b, _ := json.MarshalIndent(obj, "", " ")
arg.G().Log.Debug(fmt.Sprintf("| full reply: %s", b))
}
}
return internalResp, jw, nil
}