lib/controller/router/request.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 package router
   6
   7 import (
   8         "encoding/json"
   9         "fmt"
  10         "io"
  11         "mime"
  12         "net/http"
  13         "strconv"
  14         "strings"
  15
  16         "github.com/gorilla/mux"
  17 )
  18
  19 func guessAndParse(k, v string) (interface{}, error) {
  20         // All of these form values arrive as strings, so we need some
  21         // type-guessing to accept non-string inputs:
  22         //
  23         // Values for parameters that take ints (limit=1) or bools
  24         // (include_trash=1) are parsed accordingly.
  25         //
  26         // "null" and "" are nil.
  27         //
  28         // Values that look like JSON objects, arrays, or strings are
  29         // parsed as JSON.
  30         //
  31         // The rest are left as strings.
  32         switch {
  33         case intParams[k]:
  34                 return strconv.ParseInt(v, 10, 64)
  35         case boolParams[k]:
  36                 return stringToBool(v), nil
  37         case v == "null" || v == "":
  38                 return nil, nil
  39         case strings.HasPrefix(v, "["):
  40                 var j []interface{}
  41                 err := json.Unmarshal([]byte(v), &j)
  42                 return j, err
  43         case strings.HasPrefix(v, "{"):
  44                 var j map[string]interface{}
  45                 err := json.Unmarshal([]byte(v), &j)
  46                 return j, err
  47         case strings.HasPrefix(v, "\""):
  48                 var j string
  49                 err := json.Unmarshal([]byte(v), &j)
  50                 return j, err
  51         default:
  52                 return v, nil
  53         }
  54         // TODO: Need to accept "?foo[]=bar&foo[]=baz" as
  55         // foo=["bar","baz"]?
  56 }
  57
  58 // Parse req as an Arvados V1 API request and return the request
  59 // parameters.
  60 //
  61 // If the request has a parameter whose name is attrsKey (e.g.,
  62 // "collection"), it is renamed to "attrs".
  63 func (rtr *router) loadRequestParams(req *http.Request, attrsKey string) (map[string]interface{}, error) {
  64         err := req.ParseForm()
  65         if err != nil {
  66                 if err.Error() == "http: request body too large" {
  67                         return nil, httpError(http.StatusRequestEntityTooLarge, err)
  68                 } else {
  69                         return nil, httpError(http.StatusBadRequest, err)
  70                 }
  71         }
  72         params := map[string]interface{}{}
  73
  74         // Load parameters from req.Form, which (after
  75         // req.ParseForm()) includes the query string and -- when
  76         // Content-Type is application/x-www-form-urlencoded -- the
  77         // request body.
  78         for k, values := range req.Form {
  79                 for _, v := range values {
  80                         params[k], err = guessAndParse(k, v)
  81                         if err != nil {
  82                                 return nil, err
  83                         }
  84                 }
  85         }
  86
  87         // Decode body as JSON if Content-Type request header is
  88         // missing or application/json.
  89         mt := req.Header.Get("Content-Type")
  90         if ct, _, err := mime.ParseMediaType(mt); err != nil && mt != "" {
  91                 return nil, fmt.Errorf("error parsing media type %q: %s", mt, err)
  92         } else if (ct == "application/json" || mt == "") && req.ContentLength != 0 {
  93                 jsonParams := map[string]interface{}{}
  94                 err := json.NewDecoder(req.Body).Decode(&jsonParams)
  95                 if err != nil {
  96                         return nil, httpError(http.StatusBadRequest, err)
  97                 }
  98                 for k, v := range jsonParams {
  99                         switch v := v.(type) {
 100                         case string:
 101                                 // The Ruby "arv" cli tool sends a
 102                                 // JSON-encode params map with
 103                                 // JSON-encoded values.
 104                                 dec, err := guessAndParse(k, v)
 105                                 if err != nil {
 106                                         return nil, err
 107                                 }
 108                                 jsonParams[k] = dec
 109                                 params[k] = dec
 110                         default:
 111                                 params[k] = v
 112                         }
 113                 }
 114                 if attrsKey != "" && params[attrsKey] == nil {
 115                         // Copy top-level parameters from JSON request
 116                         // body into params[attrsKey]. Some SDKs rely
 117                         // on this Rails API feature; see
 118                         // https://api.rubyonrails.org/v5.2.1/classes/ActionController/ParamsWrapper.html
 119                         params[attrsKey] = jsonParams
 120                 }
 121         }
 122
 123         for k, v := range mux.Vars(req) {
 124                 params[k] = v
 125         }
 126
 127         if v, ok := params[attrsKey]; ok && attrsKey != "" {
 128                 params["attrs"] = v
 129                 delete(params, attrsKey)
 130         }
 131
 132         if order, ok := params["order"].(string); ok {
 133                 // We must accept strings ("foo, bar desc") and arrays
 134                 // (["foo", "bar desc"]) because RailsAPI does.
 135                 // Convert to an array here before trying to unmarshal
 136                 // into options structs.
 137                 if order == "" {
 138                         delete(params, "order")
 139                 } else {
 140                         params["order"] = strings.Split(order, ",")
 141                 }
 142         }
 143
 144         return params, nil
 145 }
 146
 147 // Copy src to dst, using json as an intermediate format in order to
 148 // invoke src's json-marshaling and dst's json-unmarshaling behaviors.
 149 func (rtr *router) transcode(src interface{}, dst interface{}) error {
 150         var errw error
 151         pr, pw := io.Pipe()
 152         go func() {
 153                 defer pw.Close()
 154                 errw = json.NewEncoder(pw).Encode(src)
 155         }()
 156         defer pr.Close()
 157         err := json.NewDecoder(pr).Decode(dst)
 158         if errw != nil {
 159                 return errw
 160         }
 161         return err
 162 }
 163
 164 var intParams = map[string]bool{
 165         "limit":  true,
 166         "offset": true,
 167 }
 168
 169 var boolParams = map[string]bool{
 170         "distinct":                true,
 171         "ensure_unique_name":      true,
 172         "include_trash":           true,
 173         "include_old_versions":    true,
 174         "redirect_to_new_user":    true,
 175         "send_notification_email": true,
 176         "bypass_federation":       true,
 177         "recursive":               true,
 178         "exclude_home_project":    true,
 179         "no_forward":              true,
 180 }
 181
 182 func stringToBool(s string) bool {
 183         switch s {
 184         case "", "false", "0":
 185                 return false
 186         default:
 187                 return true
 188         }
 189 }