Edge Security Acceleration:Logique de requête

server_addr

server_addr lit l'adresse du serveur qui a reçu la requête actuelle.

• Syntaxe — server_addr()

• Paramètres — Aucun.

• Valeur de retour — Renvoie l'adresse du serveur. Type de données : chaîne.

L'exemple suivant montre comment utiliser server_addr :

s_addr = server_addr()
say(concat('s_addr:', s_addr))

server_port

server_port lit le port du serveur qui a reçu la requête actuelle.

• Syntaxe — server_port()

• Paramètres — Aucun.

• Valeur de retour — Renvoie le port du serveur. Type de données : numérique.

L'exemple suivant montre comment utiliser server_port :

s_port = server_port()
say(concat('s_port:', tostring(s_port)))

client_addr

client_addr lit l'adresse IP du client. Pour lire plutôt la première adresse dans l'en-tête de requête X-Forwarded-For, utilisez req_first_x_forwarded.

• Syntaxe — client_addr()

• Paramètres — Aucun.

• Valeur de retour — Renvoie l'adresse IP du client. Type de données : chaîne. Pour une limitation de précision qui s'applique à client_addr, consultez Considérations.

L'exemple suivant montre comment utiliser client_addr :

c_addr = client_addr()
say(concat('c_addr:', c_addr))

client_port

client_port lit le port du client.

• Syntaxe — client_port()

• Paramètres — Aucun.

• Valeur de retour — Renvoie le port du client. Type de données : numérique.

L'exemple suivant montre comment utiliser client_port :

c_port = client_port()
say(concat('c_port:', tostring(c_port)))

client_country

client_country lit le code du pays ou de la région de l'adresse IP du client.

• Syntaxe — client_country()

• Paramètres — Aucun.

• Valeur de retour — Renvoie le code du pays ou de la région de l'adresse IP du client. Type de données : chaîne. Pour les codes de pays et de régions, consultez Codes de pays.

L'exemple suivant montre comment utiliser client_country :

c_country = client_country()
if c_country {
    say(concat('client_country:', c_country))
}

client_region

client_region lit le code de la division administrative (province ou ville) de l'adresse IP du client.

• Syntaxe — client_region()

• Paramètres — Aucun.

• Valeur de retour — Renvoie le code de la division administrative (province ou ville) de l'adresse IP du client. Type de données : chaîne. Pour les codes de division administrative, consultez Codes de division administrative.

L'exemple suivant montre comment utiliser client_region :

c_region = client_region()
if c_region {
    say(concat('client_region:', c_region))
}

client_isp

client_isp lit le code du fournisseur d'accès à Internet (FAI) de l'adresse IP du client.

• Syntaxe — client_isp()

• Paramètres — Aucun.

• Valeur de retour — Renvoie le code du fournisseur d'accès à Internet (FAI) de l'adresse IP du client. Type de données : chaîne. Pour les codes de FAI, consultez Codes de FAI.

L'exemple suivant montre comment utiliser client_isp :

c_isp = client_isp()
if c_isp {
    say(concat('client_isp:', c_isp))
}

ip_region

ip_region lit le code de la division administrative (province ou ville) d'une adresse IP spécifiée.

• Syntaxe — ip_region(ipaddr)

• Paramètres — ipaddr : chaîne d'adresse IP en notation décimale pointée.

• Valeur de retour — Renvoie le code de la division administrative (province ou ville) de l'adresse IP spécifiée. Type de données : chaîne. Pour les codes de division administrative, consultez Codes de division administrative.

L'exemple suivant montre comment utiliser ip_region :

c_region = ip_region('192.168.0.1')
if c_region {
    say(concat('ip_region:', c_region))
}

ip_isp

ip_isp lit le code du fournisseur d'accès à Internet (FAI) d'une adresse IP spécifiée.

• Syntaxe — ip_isp(ipaddr)

• Paramètres — ipaddr : chaîne d'adresse IP en notation décimale pointée.

• Valeur de retour — Renvoie le code du fournisseur d'accès à Internet (FAI) de l'adresse IP spécifiée. Type de données : chaîne. Pour les codes de FAI, consultez Codes de FAI.

L'exemple suivant montre comment utiliser ip_isp :

c_isp = ip_isp('192.168.0.1')
if c_isp {
    say(concat('ip_isp:', c_isp))
}

req_uri

req_uri lit l'URI de la requête, à l'exclusion des paramètres de requête.

• Syntaxe — req_uri([pattern])

• Paramètres — pattern : le modèle utilisé pour la correspondance. Pour les modes de correspondance pris en charge, consultez Correspondance de modèle.

• Valeur de retour

  • Sans pattern : renvoie l'URI de la requête. Type de données : chaîne.

  • Avec pattern : renvoie true si la correspondance réussit, ou false si elle échoue. Type de données : booléen.

L'exemple suivant montre comment utiliser req_uri :

# req_uri
say(concat('req_uri: ', req_uri()))
if req_uri('/path1/path2') {
    say('req_uri: plain match')
}
if req_uri('re:/path[0-9]/path[0-9]') {
    say('req_uri: regex match')
}

Cet exemple renvoie le résultat suivant :

Request: /path1/path2?mode=ip
Response:
req_uri: /path1/path2
req_uri: plain match
req_uri: regex match

req_uri_basename

req_uri_basename lit le nom de fichier dans l'URI de la requête.

• Syntaxe — req_uri_basename([pattern])

• Paramètres — pattern : le modèle utilisé pour la correspondance. Pour les modes de correspondance pris en charge, consultez Correspondance de modèle.

• Valeur de retour

  • Sans pattern : renvoie le nom de fichier dans l'URI de la requête. Type de données : chaîne.

  • Avec pattern : renvoie true si la correspondance réussit, ou false si elle échoue. Type de données : booléen.

Les exemples suivants indiquent quelle partie de l'URI de la requête correspond au nom de fichier :

• Pour /document_detail/30360.html, le nom de fichier est 30360.

• Pour /M604/guopei_mp4/ZYJY2017BJGL0101/2-1_g.mp4, le nom de fichier est 2-1_g.

• Pour /tarball/foo.tar.bz2, le nom de fichier est foo.

L'exemple suivant montre comment utiliser req_uri_basename :

# req_uri_basename
basename = req_uri_basename()
say(concat('req_uri_basename: ', basename, ' ', len(basename)))
if req_uri_basename('foo') {
    say('req_uri_basename: plain match')
}
if req_uri_basename('re:^f.*') {
    say('req_uri_basename: regex match')
}

Cet exemple renvoie le résultat suivant :

Request: /path1/path2/foo.tar.bz2
Response:
req_uri_basename: foo 3
req_uri_basename: plain match
req_uri_basename: regex match

req_uri_ext

req_uri_ext lit l'extension de fichier dans l'URI de la requête.

• Syntaxe — req_uri_ext([pattern])

• Paramètres — pattern : le modèle utilisé pour la correspondance. Pour les modes de correspondance pris en charge, consultez Correspondance de modèle.

• Valeur de retour

  • Sans pattern : renvoie l'extension de fichier dans l'URI de la requête. Type de données : chaîne.

  • Avec pattern : renvoie true si la correspondance réussit, ou false si elle échoue. Type de données : booléen.

Les exemples suivants indiquent quelle partie de l'URI de la requête correspond à l'extension de fichier :

• Pour /document_detail/30360.html, l'extension de fichier est .html.

• Pour /M604/guopei_mp4/ZYJY2017BJGL0101/2-1_g.mp4, l'extension de fichier est .mp4.

• Pour /tarball/foo.tar.bz2, l'extension de fichier est .tar.bz2.

L'exemple suivant montre comment utiliser req_uri_ext :

# req_uri_ext
ext = req_uri_ext()
say(concat('req_uri_ext: ', ext, ' ', len(ext)))
if req_uri_ext('.tar.bz2') {
    say('req_uri_ext: plain match')
}
if req_uri_ext('re:\.tar\.bz[0-2]') {
    say('req_uri_ext: regex match')
}

Cet exemple renvoie le résultat suivant :

Request: /path1/path2/foo.tar.bz2
Response:
req_uri_ext: .tar.bz2 8
req_uri_ext: plain match
req_uri_ext: regex match

req_uri_seg

La fonction req_uri_seg divise l'URI de la requête en segments à l'aide des barres obliques (/).

• Syntaxe — req_uri_seg([idx])

• Paramètres — idx (facultatif) : spécifie l'index de départ. Les index des segments commencent à 1 et augmentent de gauche à droite, depuis le début de l'URI de la requête.

• Valeur de retour

  • Sans idx : renvoie un dictionnaire contenant tous les segments. Type de données : dictionnaire.

  • Avec idx : renvoie un dictionnaire contenant les segments à partir de l'index spécifié, y compris le segment correspondant à cet index. Type de données : dictionnaire.

L'exemple suivant illustre l'utilisation de req_uri_seg :

# req_uri_seg
def echo_each(k, v, u) {
    say(concat(get(u, 'msg'), ' : segs[', k, ']=', v))
}
# fetch all segments
segs = req_uri_seg()
foreach(segs, echo_each, ['msg'='req_uri_seg()'])
# fetch segments from idx 3
segs = req_uri_seg(3)
if get(segs, 3) {
    say(concat('req_uri_seg(3): segs[3]=', get(segs, 3)))
}
if get(segs, 4) {
    say(concat('req_uri_seg(3): segs[4]=', get(segs, 4)))
}
if get(segs, 5) {
    say(concat('req_uri_seg(3): segs[5]=', get(segs, 5)))
}

Cet exemple renvoie le résultat suivant :

Request: /path1/path2/path3/path4?mode=req2
Response:
req_uri_seg() : segs[1]=path1
req_uri_seg() : segs[2]=path2
req_uri_seg() : segs[3]=path3
req_uri_seg() : segs[4]=path4
req_uri_seg(3): segs[3]=path3
req_uri_seg(3): segs[4]=path4

req_uri_arg

La fonction req_uri_arg lit la valeur d'un paramètre d'URI spécifié.

• Syntaxe — req_uri_arg(name, [pattern])

• Paramètres

  • name : nom du paramètre.

  • pattern : modèle utilisé pour la correspondance. Pour connaître les modes de correspondance pris en charge, consultez Correspondance de modèles.

• Valeur de retour

  • Sans pattern :

    • Si le paramètre existe : renvoie la valeur sous forme de chaîne du paramètre spécifié par name. Type de données : chaîne.

    • Si le paramètre n'existe pas : renvoie false.

  • Avec pattern :

    • Si le paramètre existe : effectue la correspondance et renvoie true en cas de succès, ou false en cas d'échec. Type de données : booléen.

    • Si le paramètre n'existe pas : renvoie false.

L'exemple suivant illustre l'utilisation de req_uri_arg :

# req_uri_arg
uid = req_uri_arg('uid')
if uid {
    say(concat('found uid ', uid))
} else {
    say('not found uid')
}
uid_chk = req_uri_arg('uid', '058334')
if uid_chk {
    say('check uid ok. plain mode')
} else {
    say('check uid fail. plain mode')
}
uid_chk = req_uri_arg('uid', 're:[0-9]+')
if uid_chk {
    say('check uid ok. regex mode')
} else {
    say('check uid fail. regex mode')
}

Cet exemple renvoie les résultats suivants :

Request: /path1/path2/path3/path4?mode=req4&uid
Response:
not found uid
check uid fail. plain mode
check uid fail. regex mode

Request: /path1/path2/path3/path4?mode=req4&uid=
Response:
found uid
check uid fail. plain mode
check uid fail. regex mode

Request: /path1/path2/path3/path4?mode=req4&uid=12345
Response:
found uid 12345
check uid fail. plain mode
check uid ok. regex mode

req_uri_query_string

La fonction req_uri_query_string lit les paramètres de requête, à l'exclusion du point d'interrogation (?).

• Syntaxe — req_uri_query_string([pattern])

• Paramètres — pattern : modèle utilisé pour la correspondance. Pour connaître les modes de correspondance pris en charge, consultez Correspondance de modèles.

• Valeur de retour

  • Sans pattern : renvoie les paramètres de requête. Type de données : chaîne.

  • Avec pattern : renvoie true en cas de succès de la correspondance, ou false en cas d'échec. Type de données : booléen.

L'exemple suivant illustre l'utilisation de req_uri_query_string :

# req_uri_query_string
say(concat('req_uri_query_string: ', req_uri_query_string()))
if req_uri_query_string('mode=') {
    say('check uri query string ok. plain mode')
} else {
    say('check uri query string fail. plain mode')
}
if req_uri_query_string('re:mode=[0-9a-z]+') {
    say('check uri query string ok. regex mode')
} else {
    say('check uri query string fail. regex mode')
}

Cet exemple renvoie le résultat suivant :

Request: /path1/path2/path3/path4?mode=req5&token=34Deasd#243
Response:
req_uri_query_string: mode=req5&token=34Deasd
check uri query string fail. plain mode
check uri query string ok. regex mode

req_scheme

La fonction req_scheme lit le schéma de la requête.

• Syntaxe — req_scheme([pattern])

• Paramètres — pattern : modèle utilisé pour la correspondance. Pour connaître les modes de correspondance pris en charge, consultez Correspondance de modèles.

• Valeur de retour

  • Sans pattern : renvoie le schéma de la requête. Type de données : chaîne.

  • Avec pattern : renvoie true en cas de succès de la correspondance, ou false en cas d'échec. Type de données : booléen.

L'exemple suivant illustre l'utilisation de req_scheme :

# req_scheme
say(concat('req_scheme: ', req_scheme()))
if req_scheme('https') {
    say('check scheme ok. plain mode')
} else {
    say('check scheme fail. plain mode')
}
if req_scheme('re:https?') {
    say('check scheme ok. regex mode')
} else {
    say('check scheme fail. regex mode')
}

Cet exemple renvoie le résultat suivant :

Request: http://xx..
Response:
req_scheme: http
check scheme fail. plain mode
check scheme ok. regex mode

req_method

La fonction req_method lit la méthode de la requête.

• Syntaxe — req_method([pattern])

• Paramètres — pattern : modèle utilisé pour la correspondance. Pour connaître les modes de correspondance pris en charge, consultez Correspondance de modèles.

• Valeur de retour

  • Sans pattern : renvoie la méthode de la requête. Type de données : chaîne.

  • Avec pattern : renvoie true en cas de succès de la correspondance, ou false en cas d'échec. Type de données : booléen.

L'exemple suivant illustre l'utilisation de req_method :

# req_method
say(concat('req_method: ', req_method()))
if req_method('GET') {
    say('check method ok. plain mode')
} else {
    say('check method fail. plain mode')
}
if req_method('re:(GET|POST)') {
    say('check method ok. regex mode')
} else {
    say('check method fail. regex mode')
}

Cet exemple renvoie le résultat suivant :

Request: POST /xxxx/xxx
Response:
req_method: POST
check method fail. plain mode
check method ok. regex mode

req_host

La fonction req_host lit la valeur de l'en-tête de requête Host.

• Syntaxe — req_host([pattern])

• Paramètres — pattern : modèle utilisé pour la correspondance. Pour connaître les modes de correspondance pris en charge, consultez Correspondance de modèles.

• Valeur de retour

  • Sans pattern : renvoie la valeur de l'en-tête de requête Host. Type de données : chaîne.

  • Avec pattern : renvoie true en cas de succès de la correspondance, ou false en cas d'échec. Type de données : booléen.

L'exemple suivant illustre l'utilisation de req_host :

# req_host
say(concat('req_host: ', req_host()))
if req_host('image.developer.aliyundoc.com') {
    say('check host ok. plain mode')
} else {
    say('check host fail. plain mode')
}
if req_host('re:.+\.y\.z\.com') {
    say('check host ok. regex mode')
} else {
    say('check host fail. regex mode')
}

Cet exemple renvoie le résultat suivant :

Request: Host: image.developer.aliyundoc.com
Response:
req_host: image.developer.aliyundoc.com
check host fail. plain mode
check host ok. regex mode

req_user_agent

La fonction req_user_agent lit la valeur de l'en-tête de requête User-Agent.

• Syntaxe — req_user_agent([pattern])

• Paramètres — pattern : modèle utilisé pour la correspondance. Pour connaître les modes de correspondance pris en charge, consultez Correspondance de modèles.

• Valeur de retour

  • Sans pattern : renvoie la valeur de l'en-tête de requête User-Agent. Type de données : chaîne.

  • Avec pattern : renvoie true en cas de succès de la correspondance, ou false en cas d'échec. Type de données : booléen.

L'exemple suivant illustre l'utilisation de req_user_agent :

# req_user_agent
say(concat('req_user_agent: ', req_user_agent()))
if req_user_agent('Mozilla') {
    say('check user_agent ok. plain mode')
} else {
    say('check user_agent fail. plain mode')
}
if req_user_agent('re:^Mozilla') {
    say('check user_agent ok. regex mode')
} else {
    say('check user_agent fail. regex mode')
}

Cet exemple renvoie le résultat suivant :

Request: User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)
Response:
req_user_agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)
check user_agent fail. plain mode
check user_agent ok. regex mode

req_referer

La fonction req_referer lit la valeur de l'en-tête de requête Referer.

• Syntaxe — req_referer([pattern])

• Paramètres — pattern : modèle utilisé pour la correspondance. Pour connaître les modes de correspondance pris en charge, consultez Correspondance de modèles.

• Valeur de retour

  • Sans pattern : renvoie la valeur de l'en-tête de requête Referer. Type de données : chaîne.

  • Avec pattern : renvoie true en cas de succès de la correspondance, ou false en cas d'échec. Type de données : booléen.

L'exemple suivant illustre l'utilisation de req_referer :

# req_referer
say(concat('req_referer: ', req_referer()))
if req_referer('https://example.aliyundoc.com/******00003') {
    say('check referer ok. plain mode')
} else {
    say('check referer fail. plain mode')
}
if req_referer('re:https://foo\.bar\.cn/\*+[0-9]+') {
    say('check referer ok. regex mode')
} else {
    say('check referer fail. regex mode')
}

Cet exemple renvoie le résultat suivant :

Request: Referer: https://example.aliyundoc.com/******00003
Response:
req_referer: https://example.aliyundoc.com/******00003
check referer ok. plain mode
check referer fail. regex mode

req_cookie

La fonction req_cookie lit la valeur d'un cookie spécifié.

• Syntaxe — req_cookie(name, [pattern])

• Paramètres

  • name : nom du cookie.

  • pattern : modèle utilisé pour la correspondance. Pour connaître les modes de correspondance pris en charge, consultez Correspondance de modèles.

• Valeur de retour

  • Sans pattern :

    • Si le cookie existe : renvoie la valeur sous forme de chaîne du cookie spécifié par name. Type de données : chaîne.

    • Si le cookie n'existe pas : renvoie false.

  • Avec pattern :

    • Si le cookie existe : effectue la correspondance et renvoie true en cas de succès, ou false en cas d'échec. Type de données : booléen.

    • Si le cookie n'existe pas : renvoie false.

L'exemple suivant illustre l'utilisation de req_cookie :

# req_cookie
uid = req_cookie('uid')
if uid {
    say(concat('found cookie uid ', uid))
} else {
    say('not found cookie uid')
}
uid_chk = req_cookie('uid', '058334')
if uid_chk {
    say('check cookie uid ok. plain mode')
} else {
    say('check cookie uid fail. plain mode')
}
uid_chk = req_cookie('uid', 're:^[0-9]+')
if uid_chk {
    say('check cookie uid ok. regex mode')
} else {
    say('check cookie uid fail. regex mode')
}

Cet exemple renvoie le résultat suivant :

Request: Cookie: uid=123456; token=value2
Response:
found cookie uid 123456
check cookie uid fail. plain mode
check cookie uid ok. regex mode

req_first_x_forwarded

La fonction req_first_x_forwarded lit la première adresse figurant dans l'en-tête de requête X-Forwarded-For. Pour lire l'adresse IP du client à la place, utilisez client_addr.

• Syntaxe — req_first_x_forwarded([pattern])

• Paramètres — pattern : modèle utilisé pour la correspondance. Pour connaître les modes de correspondance pris en charge, consultez Correspondance de modèles.

• Valeur de retour

  • Sans pattern : renvoie la première adresse figurant dans l'en-tête de requête X-Forwarded-For. Type de données : chaîne.

  • Avec pattern : renvoie true en cas de succès de la correspondance, ou false en cas d'échec. Type de données : booléen.

L'exemple suivant illustre l'utilisation de req_first_x_forwarded :

# req_first_x_forwarded
say(concat('req_first_x_forwarded: ', req_first_x_forwarded()))
if req_first_x_forwarded('203.0.113.1') {
    say('check first_x_forwarded ok. plain mode')
} else {
    say('check first_x_forwarded fail. plain mode')
}
if req_first_x_forwarded('re:203.0.113.[0-9]') {
    say('check first_x_forwarded ok. regex mode')
} else {
    say('check first_x_forwarded fail. regex mode')
}

Cet exemple renvoie le résultat suivant :

Request: X-Forwarded-For: 203.0.113.1, 10.10.10.10, 172.16.0.1
Response:
req_first_x_forwarded: 203.0.113.1
check first_x_forwarded ok. plain mode
check first_x_forwarded ok. regex mode

req_header

La fonction req_header lit la valeur d'un en-tête de requête spécifié.

• Syntaxe — req_header(name, [pattern])

• Paramètres

  • name : nom de l'en-tête de requête. Remplacez chaque trait d'union (-) du nom de l'en-tête par un trait de soulignement (_). Par exemple, X-USER-ID devient x_user_id.

  • pattern : modèle utilisé pour la correspondance. Pour connaître les modes de correspondance pris en charge, consultez Correspondance de modèles.

• Valeur de retour

  • Sans pattern :

    • Si l'en-tête de requête existe : renvoie la valeur sous forme de chaîne de l'en-tête spécifié par name. Type de données : chaîne.

    • Si l'en-tête de requête n'existe pas : renvoie false.

  • Avec pattern :

    • Si l'en-tête de requête existe : effectue la correspondance et renvoie true en cas de succès, ou false en cas d'échec. Type de données : booléen.

    • Si l'en-tête de requête n'existe pas : renvoie false.

L'exemple suivant illustre l'utilisation de req_header :

# req_header
uid = req_header('x_uid')
if uid {
    say(concat('found header x-uid ', uid))
} else {
    say('not found header x-uid')
}
uid_chk = req_header('x_uid', 'es developer')
if uid_chk {
    say('check header x-uid ok. plain mode')
} else {
    say('check header x-uid fail. plain mode')
}
uid_chk = req_header('x_uid', 're:es [a-z]+')
if uid_chk {
    say('check header x-uid ok. regex mode')
} else {
    say('check header x-uid fail. regex mode')
}

Cet exemple renvoie le résultat suivant :

Request: X-UID: es developer
Response:
found header x-uid es developer
check header x-uid ok. plain mode
check header x-uid ok. regex mode

req_id

La fonction req_id lit l'identifiant de la requête, qui constitue l'identifiant unique de chaque requête.

• Syntaxe — req_id()

• Paramètres — Aucun.

• Valeur de retour — Renvoie l'identifiant de la requête. Type de données : chaîne.

L'exemple suivant illustre l'utilisation de req_id :

# req_id
say(concat('req_id: ', req_id()))

Cet exemple renvoie req_id: 6451c43d15815890089411000e.