Esempio n. 1
0
static int
header_field_cb(http_parser *p, const char *buf, size_t len)
{
    request *req = get_current_request(p);
    PyObject *env = NULL, *obj = NULL;
#ifdef PY3
    char *c1, *c2;
    PyObject *f, *v;
#endif
    /* DEBUG("field key:%.*s", (int)len, buf); */

    if(req->last_header_element != FIELD){
        env = req->environ;
        if(LIMIT_REQUEST_FIELDS <= req->num_headers){
            req->bad_request_code = 400;
            return -1;
        }
#ifdef PY3
        //TODO CHECK ERROR 
        c1 = PyBytes_AS_STRING(req->field);
        f = PyUnicode_DecodeLatin1(c1, strlen(c1), NULL);
        c2 = PyBytes_AS_STRING(req->value);
        v = PyUnicode_DecodeLatin1(c2, strlen(c2), NULL);
        PyDict_SetItem(env, f, v);
        Py_DECREF(f);
        Py_DECREF(v);
#else
        PyDict_SetItem(env, req->field, req->value);
#endif
        Py_DECREF(req->field);
        Py_DECREF(req->value);
        req->field = NULL;
        req->value = NULL;
        req->num_headers++;
    }

    if(likely(req->field == NULL)){
        obj = get_http_header_key(buf, len);
    }else{
        char temp[len];
        key_upper(temp, buf, len);
        obj = concat_string(req->field, temp, len);
    }

    if(unlikely(obj == NULL)){
        req->bad_request_code = 500;
        return -1;
    }
    if(unlikely(PyBytes_GET_SIZE(obj) > LIMIT_REQUEST_FIELD_SIZE)){
        req->bad_request_code = 400;
        return -1;
    }

    req->field = obj;
    req->last_header_element = FIELD;
    return 0;
}
Esempio n. 2
0
int
header_field_cb (http_parser *p, const char *buf, size_t len, char partial)
{
  uint32_t i;
  header *h;
  client_t *client = get_client(p);
  request *req = client->req;
  char temp[len];
  
  buffer_result ret = MEMORY_ERROR;
  if (req->last_header_element != FIELD){
    if(LIMIT_REQUEST_FIELDS <= req->num_headers){
      client->bad_request_code = 400;
      return -1;
    }
    req->num_headers++;
  }
  i = req->num_headers;
  h = req->headers[i];
  
  key_upper(temp, buf, len);
  if(h){
    ret = write2buf(h->field, temp, len);
  }else{
    req->headers[i] = h = new_header(128, LIMIT_REQUEST_FIELD_SIZE, 1024, LIMIT_REQUEST_FIELD_SIZE);
    rack_header_type type = check_header_type(temp);
    if(type == OTHER){
      ret = write2buf(h->field, "HTTP_", 5);
    }
    ret = write2buf(h->field, temp, len);
    //printf("%s \n", getString(h->field));
  }
  switch(ret){
  case MEMORY_ERROR:
    client->bad_request_code = 500;
    return -1;
  case LIMIT_OVER:
    client->bad_request_code = 400;
    return -1;
  default:
    break;
  }
  req->last_header_element = FIELD;
  return 0;
}