Esempio n. 1
0
dpl_status_t
dpl_srws_get_metadata_from_headers(const dpl_dict_t *headers,
                                   dpl_dict_t *metadata)
{
  int ret;
  dpl_var_t *var;
  int value_len;
  char *orig;
  int orig_len;
  struct mdparse_data arg;

  DPRINTF("srws_get_metadata_from_headers\n");

  memset(&arg, 0, sizeof (arg));

  var = dpl_dict_get(headers, DPL_SRWS_X_BIZ_USERMD);
  if (NULL == var)
    {
      //no metadata;
      ret = DPL_SUCCESS;
      goto end;
    }

  DPRINTF("val=%s\n", var->value);

  //decode base64
  value_len = strlen(var->value);
  if (value_len == 0)
    return DPL_EINVAL;

  orig_len = DPL_BASE64_ORIG_LENGTH(value_len);
  orig = alloca(orig_len);

  orig_len = dpl_base64_decode((u_char *) var->value, value_len, (u_char *) orig);
  
  //dpl_dump_simple(orig, orig_len);

  arg.metadata = metadata;
  arg.orig = orig;
  arg.orig_len = orig_len;
  ret = dpl_ntinydb_list(orig, orig_len, cb_ntinydb, &arg);
  if (DPL_SUCCESS != ret)
    goto end;

  ret = DPL_SUCCESS;
  
 end:

  return ret;
}
Esempio n. 2
0
dpl_status_t
dpl_cdmi_get(dpl_ctx_t *ctx,
             const char *bucket,
             const char *resource,
             const char *subresource,
             const dpl_option_t *option,
             dpl_ftype_t object_type,
             const dpl_condition_t *condition,
             const dpl_range_t *range,
             char **data_bufp,
             unsigned int *data_lenp,
             dpl_dict_t **metadatap,
             dpl_sysmd_t *sysmdp,
             char **locationp)
{
  int           ret, ret2;
  dpl_conn_t   *conn = NULL;
  char          header[dpl_header_size];
  u_int         header_len;
  struct iovec  iov[10];
  int           n_iov = 0;
  int           connection_close = 0;
  char          *data_buf = NULL;
  u_int         data_len;
  dpl_dict_t    *headers_request = NULL;
  dpl_dict_t    *headers_reply = NULL;
  dpl_req_t     *req = NULL;
  int raw = 0;
  dpl_value_t *val = NULL;
  dpl_dict_var_t *var = NULL;
  dpl_dict_var_t *encoding = NULL;
  int value_len;
  int orig_len;
  char *orig_buf = NULL;
  dpl_cdmi_req_mask_t req_mask = 0u;
  char *location;

  DPL_TRACE(ctx, DPL_TRACE_BACKEND, "");

  if (option)
    {
      if (option->mask & DPL_OPTION_HTTP_COMPAT)
        req_mask |= DPL_CDMI_REQ_HTTP_COMPAT;

      if (option->mask & DPL_OPTION_RAW)
        raw = 1;
    }

  req = dpl_req_new(ctx);
  if (NULL == req)
    {
      ret = DPL_ENOMEM;
      goto end;
    }

  dpl_req_set_method(req, DPL_METHOD_GET);

  if (NULL != bucket)
    {
      ret2 = dpl_req_set_bucket(req, bucket);
      if (DPL_SUCCESS != ret2)
        {
          ret = ret2;
          goto end;
        }
    }

  ret2 = dpl_cdmi_req_set_resource(req, resource);
  if (DPL_SUCCESS != ret2)
    {
      ret = ret2;
      goto end;
    }

  if (NULL == subresource)
    {
      if (DPL_FTYPE_REG == object_type)
        {
          subresource = "valuetransferencoding";
        }
    }

  if (NULL != subresource)
    {
      ret2 = dpl_req_set_subresource(req, subresource);
      if (DPL_SUCCESS != ret2)
        {
          ret = ret2;
          goto end;
        }
    }

  if (NULL != condition)
    {
      dpl_req_set_condition(req, condition);
    }

  if (range)
    {
      ret2 = dpl_cdmi_req_add_range(req, req_mask, range);
      if (DPL_SUCCESS != ret2)
        {
          ret = ret2;
          goto end;
        }
    }

  dpl_req_set_object_type(req, object_type);

  //build request
  ret2 = dpl_cdmi_req_build(req, 0, &headers_request, NULL, NULL);
  if (DPL_SUCCESS != ret2)
    {
      ret = ret2;
      goto end;
    }

  //contact default host
  dpl_req_rm_behavior(req, DPL_BEHAVIOR_VIRTUAL_HOSTING);

  ret2 = dpl_try_connect(ctx, req, &conn);
  if (DPL_SUCCESS != ret2)
    {
      ret = ret2;
      goto end;
    }

  ret2 = dpl_add_host_to_headers(req, headers_request);
  if (DPL_SUCCESS != ret2)
    {
      ret = ret2;
      goto end;
    }

  ret2 = dpl_req_gen_http_request(ctx, req, headers_request, NULL, header, sizeof (header), &header_len);
  if (DPL_SUCCESS != ret2)
    {
      ret = ret2;
      goto end;
    }

  iov[n_iov].iov_base = header;
  iov[n_iov].iov_len = header_len;
  n_iov++;

  //final crlf
  iov[n_iov].iov_base = "\r\n";
  iov[n_iov].iov_len = 2;
  n_iov++;

  ret2 = dpl_conn_writev_all(conn, iov, n_iov, conn->ctx->write_timeout);
  if (DPL_SUCCESS != ret2)
    {
      DPL_TRACE(conn->ctx, DPL_TRACE_ERR, "writev failed");
      connection_close = 1;
      ret = ret2;
      goto end;
    }

  if (option && option->mask & DPL_OPTION_NOALLOC)
    {
      data_buf = *data_bufp;
      data_len = *data_lenp;
    }

  ret2 = dpl_read_http_reply_ext(conn, 1, 
                                 (option && option->mask & DPL_OPTION_NOALLOC) ? 1 : 0,
                                 &data_buf, &data_len, &headers_reply, &connection_close);
  if (DPL_SUCCESS != ret2)
    {
      if (DPL_EREDIRECT == ret2)
        {
          if (NULL != locationp)
            {
              location = dpl_location(headers_reply);
              if (NULL == location)
                {
                  DPL_TRACE(conn->ctx, DPL_TRACE_ERR,
                            "missing \"Location\" header in redirect HTTP response");
                  connection_close = 1;
                  ret = DPL_FAILURE;
                  goto end;
                }
              *locationp = strdup(location);
            }
        }
      ret = ret2;
      goto end;
    }

  if (req_mask & DPL_CDMI_REQ_HTTP_COMPAT)
    {
      //metadata are in headers
      ret2 = dpl_cdmi_get_metadata_from_headers(headers_reply, metadatap, sysmdp);
      if (DPL_SUCCESS != ret2)
        {
          ret = ret2;
          goto end;
        }
    }
  else
    {
      if (!raw)
        {
          char *tmp;

          //extract data+metadata from json
          ret2 = dpl_cdmi_parse_json_buffer(ctx, data_buf, data_len, &val);
          if (DPL_SUCCESS != ret2)
            {
              ret = ret2;
              goto end;
            }
          
          if (DPL_VALUE_SUBDICT != val->type)
            {
              ret = DPL_EINVAL;
              goto end;
            }

          ret2 = dpl_cdmi_get_metadata_from_values(val->subdict, metadatap, sysmdp);
          if (DPL_SUCCESS != ret2)
            {
              ret = ret2;
              goto end;
            }
          
          //find the value object
          ret2 = dpl_dict_get_lowered(val->subdict, "value", &var);
          if (DPL_SUCCESS != ret2)
            {
              ret = ret2;
              goto end;
            }
          
          if (DPL_VALUE_STRING != var->val->type)
            {
              ret = DPL_EINVAL;
              goto end;
            }
          
          ret2 = dpl_dict_get_lowered(val->subdict, "valuetransferencoding",
                                      &encoding);
          if (DPL_SUCCESS != ret2)
            {
              ret = ret2;
              goto end;
            }

          if (DPL_VALUE_STRING != encoding->val->type)
            {
              ret = DPL_EINVAL;
              goto end;
            }

          value_len = var->val->string->len;

          if (0 == strcmp(dpl_sbuf_get_str(encoding->val->string), "base64"))
            {
              orig_len = DPL_BASE64_ORIG_LENGTH(value_len);
              orig_buf = malloc(orig_len);
              if (NULL == orig_buf)
                {
                  ret = DPL_ENOMEM;
                  goto end;
                }
          
              orig_len = dpl_base64_decode((u_char *) dpl_sbuf_get_str(var->val->string), value_len, (u_char *) orig_buf);
          
              //swap pointers
              tmp = data_buf;
              data_buf = orig_buf;
              orig_buf = tmp;
              data_len = orig_len;
            }
          else if (0 == strcmp(dpl_sbuf_get_str(encoding->val->string), "utf-8"))
            {
              orig_buf = data_buf;
              orig_len = data_len;
              data_buf = malloc(value_len + 1);
              if (NULL == data_buf)
                {
                  ret = DPL_ENOMEM;
                  goto end;
                }
              memcpy(data_buf, dpl_sbuf_get_str(var->val->string), value_len);
              data_buf[value_len] = '\0';
              data_len = value_len;
            }
          else
            {
              DPL_TRACE(conn->ctx, DPL_TRACE_ERR,
                        "unknown \"valuetransferencoding\" received: \"%s\"",
                        encoding->val->string);
              ret = DPL_EINVAL;
              goto end;
            }
        }
    }

  if (NULL != data_bufp)
    {
      *data_bufp = data_buf;
      data_buf = NULL; //consume it
    }

  if (NULL != data_lenp)
    *data_lenp = data_len;

  ret = DPL_SUCCESS;

 end:

  if (NULL != orig_buf)
    free(orig_buf);

  if (NULL != val)
    dpl_value_free(val);

  if ((option && !(option->mask & DPL_OPTION_NOALLOC)) && NULL != data_buf)
    free(data_buf);

  if (NULL != conn)
    {
      if (1 == connection_close)
        dpl_conn_terminate(conn);
      else
        dpl_conn_release(conn);
    }

  if (NULL != headers_reply)
    dpl_dict_free(headers_reply);

  if (NULL != headers_request)
    dpl_dict_free(headers_request);

  if (NULL != req)
    dpl_req_free(req);

  DPL_TRACE(ctx, DPL_TRACE_BACKEND, "ret=%d", ret);

  return ret;
}