自学教程：C++ GET_HTTP_CONTEXT函数代码示例

static intts_lua_http_set_parent_proxy(lua_State *L){  int n = 0;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  n = lua_gettop(L);  if (n == 2) {    const char *hostname;    size_t hostname_len;    int port = 0;    hostname = luaL_checklstring(L, 1, &hostname_len);    port     = luaL_checkinteger(L, 2);    TSHttpTxnParentProxySet(http_ctx->txnp, hostname, port);  } else {    return luaL_error(L, "incorrect # of arguments for set_parent_proxy, receiving %d instead of 2", n);  }  return 0;}

static intts_lua_server_request_server_addr_get_outgoing_port(lua_State *L){  struct sockaddr const *outgoing_addr;  ts_lua_http_ctx *http_ctx;  int port;  GET_HTTP_CONTEXT(http_ctx, L);  outgoing_addr = TSHttpTxnOutgoingAddrGet(http_ctx->txnp);  if (outgoing_addr == NULL) {    lua_pushnil(L);  } else {    if (outgoing_addr->sa_family == AF_INET) {      port = ((struct sockaddr_in *)outgoing_addr)->sin_port;    } else {      port = ((struct sockaddr_in6 *)outgoing_addr)->sin6_port;    }    lua_pushnumber(L, ntohs(port));  }  return 1;}

static intts_lua_remap_get_to_uri(lua_State *L){  char uri[TS_LUA_MAX_URL_LENGTH];  const char *path;  int path_len;  int uri_len;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  if (http_ctx->rri != NULL) {    path = TSUrlPathGet(http_ctx->client_request_bufp, http_ctx->rri->mapToUrl, &path_len);    uri_len = snprintf(uri, TS_LUA_MAX_URL_LENGTH, "/%.*s", path_len, path);    if (uri_len >= TS_LUA_MAX_URL_LENGTH) {      lua_pushlstring(L, uri, TS_LUA_MAX_URL_LENGTH - 1);    } else {      lua_pushlstring(L, uri, uri_len);    }  } else {    lua_pushnil(L);  }  return 1;}

static intts_lua_server_request_get_uri(lua_State *L){  char uri[TS_LUA_MAX_URL_LENGTH];  const char *path;  int path_len;  int uri_len;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  TS_LUA_CHECK_SERVER_REQUEST_URL(http_ctx);  path = TSUrlPathGet(http_ctx->server_request_bufp, http_ctx->server_request_url, &path_len);  uri_len = snprintf(uri, TS_LUA_MAX_URL_LENGTH, "/%.*s", path_len, path);  if (uri_len >= TS_LUA_MAX_URL_LENGTH) {    lua_pushlstring(L, uri, TS_LUA_MAX_URL_LENGTH - 1);  } else {    lua_pushlstring(L, uri, uri_len);  }  return 1;}

static intts_lua_cached_response_header_get(lua_State *L){  const char *key;  const char *val;  int val_len;  size_t key_len;  TSMLoc field_loc;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  /*   we skip the first argument that is the table */  key = luaL_checklstring(L, 2, &key_len);  TS_LUA_CHECK_CACHED_RESPONSE_HDR(http_ctx);  if (key && key_len) {    field_loc = TSMimeHdrFieldFind(http_ctx->cached_response_bufp, http_ctx->cached_response_hdrp, key, key_len);    if (field_loc) {      val = TSMimeHdrFieldValueStringGet(http_ctx->cached_response_bufp, http_ctx->cached_response_hdrp, field_loc, -1, &val_len);      lua_pushlstring(L, val, val_len);      TSHandleMLocRelease(http_ctx->cached_response_bufp, http_ctx->cached_response_hdrp, field_loc);    } else {      lua_pushnil(L);    }  } else {    lua_pushnil(L);  }  return 1;}

static intts_lua_server_request_server_addr_get_ip(lua_State *L){  struct sockaddr const *server_ip;  char sip[128];  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  server_ip = TSHttpTxnServerAddrGet(http_ctx->txnp);  if (server_ip == NULL) {    lua_pushnil(L);  } else {    if (server_ip->sa_family == AF_INET) {      inet_ntop(AF_INET, (const void *)&((struct sockaddr_in *)server_ip)->sin_addr, sip, sizeof(sip));    } else {      inet_ntop(AF_INET6, (const void *)&((struct sockaddr_in6 *)server_ip)->sin6_addr, sip, sizeof(sip));    }    lua_pushstring(L, sip);  }  return 1;}

static intts_lua_remap_get_to_url(lua_State *L){  char output[TS_LUA_MAX_URL_LENGTH];  char *url;  int url_len;  int output_len;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  if (http_ctx->rri != NULL) {    url = TSUrlStringGet(http_ctx->client_request_bufp, http_ctx->rri->mapToUrl, &url_len);    output_len = snprintf(output, TS_LUA_MAX_URL_LENGTH, "%.*s", url_len, url);    if (output_len >= TS_LUA_MAX_URL_LENGTH) {      lua_pushlstring(L, output, TS_LUA_MAX_URL_LENGTH - 1);    } else {      lua_pushlstring(L, output, output_len);    }    TSfree(url);  } else {    lua_pushnil(L);  }  return 1;}

static intts_lua_server_response_get_version(lua_State *L){  int version;  char buf[32];  int n;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  TS_LUA_CHECK_SERVER_RESPONSE_HDR(http_ctx);  version = TSHttpHdrVersionGet(http_ctx->server_response_bufp, http_ctx->server_response_hdrp);  n = snprintf(buf, sizeof(buf), "%d.%d", TS_HTTP_MAJOR(version), TS_HTTP_MINOR(version));  if (n >= (int)sizeof(buf)) {    lua_pushlstring(L, buf, sizeof(buf) - 1);  } else if (n > 0) {    lua_pushlstring(L, buf, n);  }  return 1;}

static intts_lua_http_get_remap_to_url(lua_State *L){  TSMLoc url = TS_NULL_MLOC;  char *str  = NULL;  int len;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  if (TSRemapToUrlGet(http_ctx->txnp, &url) != TS_SUCCESS) {    lua_pushnil(L);    goto done;  }  str = TSUrlStringGet(NULL, url, &len);  lua_pushlstring(L, str, len >= TS_LUA_MAX_URL_LENGTH ? TS_LUA_MAX_URL_LENGTH - 1 : len);done:  if (str != NULL) {    TSfree(str);  }  return 1;}

static intts_lua_http_set_cache_lookup_url(lua_State *L){  const char *url;  size_t url_len;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  url = luaL_checklstring(L, 1, &url_len);  if (url && url_len) {    const char *start = url;    const char *end = url + url_len;    TSMLoc new_url_loc;    if (TSUrlCreate(http_ctx->client_request_bufp, &new_url_loc) == TS_SUCCESS &&        TSUrlParse(http_ctx->client_request_bufp, new_url_loc, &start, end) == TS_PARSE_DONE &&        TSHttpTxnCacheLookupUrlSet(http_ctx->txnp, http_ctx->client_request_bufp, new_url_loc) == TS_SUCCESS) {      TSDebug(TS_LUA_DEBUG_TAG, "Set cache lookup URL");    } else {      TSError("[ts_lua] Failed to set cache lookup URL");    }  }  return 0;}

static intts_lua_server_request_get_headers(lua_State *L){  const char *name;  const char *value;  int name_len;  int value_len;  TSMLoc field_loc;  TSMLoc next_field_loc;  const char *tvalue;  size_t tvalue_len;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  TS_LUA_CHECK_SERVER_REQUEST_HDR(http_ctx);  lua_newtable(L);  field_loc = TSMimeHdrFieldGet(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, 0);  while (field_loc != TS_NULL_MLOC) {    name = TSMimeHdrFieldNameGet(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, field_loc, &name_len);    if (name && name_len) {      // retrieve the header name from table      lua_pushlstring(L, name, name_len);      lua_gettable(L, -2);      if (lua_isnil(L, -1)) {        // if header name does not exist in the table, insert it        lua_pop(L, 1);        value =          TSMimeHdrFieldValueStringGet(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, field_loc, -1, &value_len);        lua_pushlstring(L, name, name_len);        lua_pushlstring(L, value, value_len);        lua_rawset(L, -3);      } else {        // if header name exists in the table, append a command and the new value to the end of the existing value        tvalue = lua_tolstring(L, -1, &tvalue_len);        lua_pop(L, 1);        value =          TSMimeHdrFieldValueStringGet(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, field_loc, -1, &value_len);        lua_pushlstring(L, name, name_len);        lua_pushlstring(L, tvalue, tvalue_len);        lua_pushlstring(L, ",", 1);        lua_pushlstring(L, value, value_len);        lua_concat(L, 3);        lua_rawset(L, -3);      }    }    next_field_loc = TSMimeHdrFieldNext(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, field_loc);    TSHandleMLocRelease(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, field_loc);    field_loc = next_field_loc;  }  return 1;}

static intts_lua_client_response_set_error_resp(lua_State *L){  int n, status;  const char *body;  const char *reason;  int reason_len;  size_t body_len;  int resp_len;  char *resp_buf;  TSMLoc field_loc;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  TS_LUA_CHECK_CLIENT_RESPONSE_HDR(http_ctx);  n = lua_gettop(L);  status = luaL_checkinteger(L, 1);  reason = TSHttpHdrReasonLookup(status);  reason_len = strlen(reason);  TSHttpHdrStatusSet(http_ctx->client_response_bufp, http_ctx->client_response_hdrp, status);  TSHttpHdrReasonSet(http_ctx->client_response_bufp, http_ctx->client_response_hdrp, reason, reason_len);  body_len = 0;  if (n == 2) {    body = luaL_checklstring(L, 2, &body_len);  }  if (body_len && body) {    resp_buf = TSmalloc(body_len);    memcpy(resp_buf, body, body_len);    resp_len = body_len;  } else {    resp_buf = TSmalloc(reason_len);    memcpy(resp_buf, reason, reason_len);    resp_len = reason_len;  }  field_loc = TSMimeHdrFieldFind(http_ctx->client_response_bufp, http_ctx->client_response_hdrp, TS_MIME_FIELD_TRANSFER_ENCODING,                                 TS_MIME_LEN_TRANSFER_ENCODING);  if (field_loc) {    TSMimeHdrFieldDestroy(http_ctx->client_response_bufp, http_ctx->client_response_hdrp, field_loc);    TSHandleMLocRelease(http_ctx->client_response_bufp, http_ctx->client_response_hdrp, field_loc);  }  TSHttpTxnErrorBodySet(http_ctx->txnp, resp_buf, resp_len, NULL);  return 0;}

static intts_lua_server_request_header_set(lua_State *L){  const char *key;  const char *val;  size_t val_len;  size_t key_len;  int remove;  TSMLoc field_loc;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  remove = 0;  val = NULL;  /*   we skip the first argument that is the table */  key = luaL_checklstring(L, 2, &key_len);  if (lua_isnil(L, 3)) {    remove = 1;  } else {    val = luaL_checklstring(L, 3, &val_len);  }  if (!http_ctx->server_request_hdrp) {    if (TSHttpTxnServerReqGet(http_ctx->txnp, &http_ctx->server_request_bufp, &http_ctx->server_request_hdrp) != TS_SUCCESS) {      return 0;    }  }  field_loc = TSMimeHdrFieldFind(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, key, key_len);  if (remove) {    if (field_loc) {      TSMimeHdrFieldDestroy(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, field_loc);    }  } else if (field_loc) {    TSMimeHdrFieldValueStringSet(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, field_loc, -1, val, val_len);  } else if (TSMimeHdrFieldCreateNamed(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, key, key_len, &field_loc) !=             TS_SUCCESS) {    TSError("[ts_lua][%s] TSMimeHdrFieldCreateNamed error", __FUNCTION__);    return 0;  } else {    TSMimeHdrFieldValueStringSet(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, field_loc, -1, val, val_len);    TSMimeHdrFieldAppend(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, field_loc);  }  if (field_loc)    TSHandleMLocRelease(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, field_loc);  return 0;}

static intts_lua_http_is_websocket(lua_State *L){  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  lua_pushboolean(L, TSHttpTxnIsWebsocket(http_ctx->txnp));  return 1;}

static intts_lua_http_get_id(lua_State *L){  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  uint64_t id = TSHttpTxnIdGet(http_ctx->txnp);  lua_pushnumber(L, id);  return 1;}

static intts_lua_server_request_header_get(lua_State *L){  const char *key;  const char *val;  int val_len;  size_t key_len;  int count;  TSMLoc field_loc, next_field_loc;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  /*  we skip the first argument that is the table */  key = luaL_checklstring(L, 2, &key_len);  if (!http_ctx->server_request_hdrp) {    if (TSHttpTxnServerReqGet(http_ctx->txnp, &http_ctx->server_request_bufp, &http_ctx->server_request_hdrp) != TS_SUCCESS) {      lua_pushnil(L);      return 1;    }  }  if (key && key_len) {    field_loc = TSMimeHdrFieldFind(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, key, key_len);    if (field_loc != TS_NULL_MLOC) {      count = 0;      while (field_loc != TS_NULL_MLOC) {        val = TSMimeHdrFieldValueStringGet(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, field_loc, -1, &val_len);        next_field_loc = TSMimeHdrFieldNextDup(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, field_loc);        lua_pushlstring(L, val, val_len);        count++;        // multiple headers with the same name must be semantically the same as one value which is comma seperated        if (next_field_loc != TS_NULL_MLOC) {          lua_pushlstring(L, ",", 1);          count++;        }        TSHandleMLocRelease(http_ctx->server_request_bufp, http_ctx->server_request_hdrp, field_loc);        field_loc = next_field_loc;      }      lua_concat(L, count);    } else {      lua_pushnil(L);    }  } else {    lua_pushnil(L);  }  return 1;}

static intts_lua_http_get_server_state(lua_State *L){  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  TSServerState ss = TSHttpTxnServerStateGet(http_ctx->txnp);  lua_pushnumber(L, ss);  return 1;}

static intts_lua_http_set_retstatus(lua_State *L){  int status;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  status = luaL_checkinteger(L, 1);  TSHttpTxnSetHttpRetStatus(http_ctx->txnp, status);  return 0;}

static intts_lua_http_get_plugin_tag(lua_State *L){  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  const char *tag = TSHttpTxnPluginTagGet(http_ctx->txnp);  lua_pushstring(L, tag);  return 1;}

static intts_lua_server_request_get_body_size(lua_State *L){  int64_t body_size;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  body_size = TSHttpTxnServerReqBodyBytesGet(http_ctx->txnp);  lua_pushnumber(L, body_size);  return 1;}

static intts_lua_http_set_retbody(lua_State *L){  const char *body;  size_t body_len;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  body = luaL_checklstring(L, 1, &body_len);  TSHttpTxnErrorBodySet(http_ctx->txnp, TSstrdup(body), body_len, NULL); // Defaults to text/html  return 0;}

static intts_lua_server_request_get_header_size(lua_State *L){  int header_size;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  header_size = TSHttpTxnServerReqHdrBytesGet(http_ctx->txnp);  lua_pushnumber(L, header_size);  return 1;}

static intts_lua_http_skip_remapping_set(lua_State *L){  int action;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  action = luaL_checkinteger(L, 1);  TSSkipRemappingSet(http_ctx->txnp, action);  return 0;}

static intts_lua_http_resp_cache_untransformed(lua_State *L){  int action;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  action = luaL_checkinteger(L, 1);  TSHttpTxnUntransformedRespCache(http_ctx->txnp, action);  return 0;}

static intts_lua_http_server_push(lua_State *L){  const char *url;  size_t url_len;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  url = luaL_checklstring(L, 1, &url_len);  TSHttpTxnServerPush(http_ctx->txnp, url, url_len);  return 0;}

static intts_lua_http_server_packet_dscp_set(lua_State *L){  int value;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  value = luaL_checkinteger(L, 1);  TSDebug(TS_LUA_DEBUG_TAG, "server packet dscp set");  TSHttpTxnServerPacketDscpSet(http_ctx->txnp, value);  return 0;}

static intts_lua_http_client_packet_tos_set(lua_State *L){  int value;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  value = luaL_checkinteger(L, 1);  TSDebug(TS_LUA_DEBUG_TAG, "client packet tos set");  TSHttpTxnClientPacketTosSet(http_ctx->txnp, value);  return 0;}

static intts_lua_http_set_debug(lua_State *L){  int value;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  value = luaL_checkinteger(L, 1);  TSDebug(TS_LUA_DEBUG_TAG, "set debug");  TSHttpTxnDebugSet(http_ctx->txnp, value);  return 0;}

static intts_lua_http_enable_redirect(lua_State *L){  int value;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  value = luaL_checkinteger(L, 1);  TSDebug(TS_LUA_DEBUG_TAG, "enable redirect");  TSHttpTxnFollowRedirect(http_ctx->txnp, value);  return 0;}

static intts_lua_http_set_cache_lookup_status(lua_State *L){  int status;  ts_lua_http_ctx *http_ctx;  GET_HTTP_CONTEXT(http_ctx, L);  status = luaL_checknumber(L, 1);  TSHttpTxnCacheLookupStatusSet(http_ctx->txnp, status);  return 0;}