应要求拒绝服务资源耗尽

Question

In my project, there is one func to iterate list of items, then for each item to call one func to make GET request to retrieve some params. When we use the checkmarx to do the scan, it points to the resp, err := http.Get(url) and says

The resource Get allocated is prone to resource exhaustion when used by another func

Below is the getParams() func. Is there any potential resource exhaustion for this func?

func getParams() (float64, float64, error) {
    url := "http://url.to.get.response"
    // the resource allocated below is prone to resource exhaustion?
    resp, err := http.Get(url)
    if err != nil {
        log.Error(err.Error(), err)
        return -1.0, -1.0, err
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Error(err.Error(), err)
    }

    json.Unmarshal(body, &result)

    if routes, ok := result["routes"].([]interface{}); ok {
        route := routes[0].(map[string]interface{})
        summary := route["summary"].(map[string]interface{})
        secs := summary["seconds"]
        meters := summary["meters"].(float64)
        var mins float64
        if etai, ok := secs.(float64); ok {
            mins = etai / 60
        } else {
            mins = 0
        }
        return mins, meters, nil
    }

    return -1.0, -1.0, nil
}

Answer 1

Is there a cap on top on the loop, in other words if the list is 10M elements, will the code try to send 10M requests?

Remember web requests use random source port for the session and those are limited in quantity, also establishing a connection is a subject to memory allocation, which too is a limiting factor that you may want to account for. To top it off, the operating system can have its own limit on number of simultaneous active "descriptors".

Not sure if this is what the error is trying to tell you, just my best guess. If so, you may want to introduce some synchronization into the code, so that only n-number of connections are established at a time.