CDN:Fonctions de logique de requête

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

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

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

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

c_country = client_country()
c_region = client_region()
c_city = client_city()
c_isp = client_isp()
if c_country {
    say(concat('client_country:', c_country))
}
if c_region {
    say(concat('client_region:', c_region))
}
if c_city { 
    say(concat('client_city:', c_city)) 
}
if c_isp {
    say(concat('client_isp:', c_isp))
}

c_country = client_country()
c_region = client_region()
c_city = client_city()
c_isp = client_isp()
if c_country {
    say(concat('client_country:', c_country))
}
if c_region {
    say(concat('client_region:', c_region))
}
if c_city { 
    say(concat('client_city:', c_city)) 
}
if c_isp {
    say(concat('client_isp:', c_isp))
}

c_country = ip_country('192.168.0.1')
c_region = ip_region('192.168.0.1')
c_city = ip_city('192.168.0.1')
c_isp = ip_isp('192.168.0.1')
if c_country {
    say(concat('ip_country:', c_country))
}
if c_region {
    say(concat('ip_region:', c_region))
}
if c_city {
    say(concat('ip_city:', c_city))
}
if c_isp {
    say(concat('ip_isp:', c_isp))
}

c_country = ip_country('192.168.0.1')
c_region = ip_region('192.168.0.1')
c_city = ip_city('192.168.0.1')
c_isp = ip_isp('192.168.0.1')
if c_country {
    say(concat('ip_country:', c_country))
}
if c_region {
    say(concat('ip_region:', c_region))
}
if c_city {
    say(concat('ip_city:', c_city))
}
if c_isp {
    say(concat('ip_isp:', c_isp))
}

• Algorithme de force brute : compare les valeurs selon un algorithme de force brute. Il s'agit du type de correspondance par défaut.
• Expression régulière : compare les valeurs selon une expression régulière précédée de re:.

# 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')
}

• Si le paramètre pattern n'est pas inclus dans la requête, l'URI de la requête est renvoyé. Type de données : string.
• Si le paramètre pattern est inclus dans la requête et que la requête correspond aux conditions de correspondance, la valeur true est renvoyée. Si aucune condition ne correspond, la valeur false est renvoyée.

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

• Algorithme de force brute : compare les valeurs selon un algorithme de force brute. Il s'agit du type de correspondance par défaut.
• Expression régulière : compare les valeurs selon une expression régulière précédée de re:.

# 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')
}

• Renvoie le nom de fichier dans l'URI de la requête si le paramètre pattern n'est pas inclus dans la requête. Type de données : string.
• Si le paramètre pattern est inclus dans la requête et que la requête correspond aux conditions de correspondance, la valeur true est renvoyée. Si aucune condition ne correspond, la valeur false est renvoyée.

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

• Algorithme de force brute : compare les valeurs selon un algorithme de force brute. Il s'agit du type de correspondance par défaut.
• Expression régulière : compare les valeurs selon une expression régulière précédée de re:.

# 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')
}

• Renvoie l'extension dans l'URI de la requête si le paramètre pattern n'est pas inclus dans la requête. Type de données : string.
• Si le paramètre pattern est inclus dans la requête et que la requête correspond aux conditions de correspondance, la valeur true est renvoyée. Si aucune condition ne correspond, la valeur false est renvoyée.

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
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)))
}

• name : le nom du paramètre.
• pattern : comparé aux conditions de correspondance. Les types de correspondance suivants sont pris en charge :
  • Algorithme de force brute : compare les valeurs selon un algorithme de force brute. Il s'agit du type de correspondance par défaut.
  • Expression régulière : compare les valeurs selon une expression régulière précédée de re:.

# 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')
}

• Si le paramètre pattern n'est pas inclus dans la requête
  • Le paramètre spécifié existe : renvoie la valeur du paramètre spécifié par le paramètre name sous forme de chaîne.
  • Le paramètre spécifié n'existe pas : renvoie la valeur false.
• Si le paramètre pattern est inclus dans la requête
  • Le paramètre spécifié existe : renvoie la valeur true si la valeur correspond aux conditions de correspondance. Sinon, la valeur false est renvoyée.
  • Le paramètre spécifié n'existe pas : renvoie la valeur false.

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

• Algorithme de force brute : compare les valeurs selon un algorithme de force brute. Il s'agit du type de correspondance par défaut.
• Expression régulière : compare les valeurs selon une expression régulière précédée de re:.

# 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')
}

• Renvoie les paramètres de la requête si le paramètre pattern n'est pas inclus dans la requête. Type de données : string.
• Si le paramètre pattern est inclus dans la requête et que la requête correspond aux conditions de correspondance, la valeur true est renvoyée. Si aucune condition ne correspond, la valeur false est renvoyée.

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

• Algorithme de force brute : compare les valeurs selon un algorithme de force brute. Il s'agit du type de correspondance par défaut.
• Expression régulière : compare les valeurs selon une expression régulière précédée de re:.

# 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')
}

• Renvoie le schéma de la requête si le paramètre pattern n'est pas inclus dans la requête. Type de données : string.
• Si le paramètre pattern est inclus dans la requête et que la requête correspond aux conditions de correspondance, la valeur true est renvoyée. Si aucune condition ne correspond, la valeur false est renvoyée.

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

• Algorithme de force brute : compare les valeurs selon un algorithme de force brute. Il s'agit du type de correspondance par défaut.
• Expression régulière : compare les valeurs selon une expression régulière précédée de re:.

# 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')
}

• Renvoie la méthode de requête si le paramètre pattern n'est pas inclus dans la requête. Type de données : string.
• Si le paramètre pattern est inclus dans la requête et que la requête correspond aux conditions de correspondance, la valeur true est renvoyée. Si aucune condition ne correspond, la valeur false est renvoyée.

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

• Algorithme de force brute : compare les valeurs selon un algorithme de force brute. Il s'agit du type de correspondance par défaut.
• Expression régulière : compare les valeurs selon une expression régulière précédée de re:.

# 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')
}

• Renvoie la valeur de l'en-tête de requête Host si le paramètre pattern n'est pas inclus dans la requête. Type de données : string.
• Si le paramètre pattern est inclus dans la requête et que la requête correspond aux conditions de correspondance, la valeur true est renvoyée. Si aucune condition ne correspond, la valeur false est renvoyée.

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

• Algorithme de force brute : compare les valeurs selon un algorithme de force brute. Il s'agit du type de correspondance par défaut.
• Expression régulière : compare les valeurs selon une expression régulière précédée de re:.

# 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')
}

• Renvoie la valeur de l'en-tête de requête User-Agent si le paramètre pattern n'est pas inclus dans la requête. Type de données : string.
• Si le paramètre pattern est inclus dans la requête et que la requête correspond aux conditions de correspondance, la valeur true est renvoyée. Si aucune condition ne correspond, la valeur false est renvoyée.

ua: specifies user agents. 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

• Algorithme de force brute : compare les valeurs selon un algorithme de force brute. Il s'agit du type de correspondance par défaut.
• Expression régulière : compare les valeurs selon une expression régulière précédée de re:.

# 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')
}

• Renvoie la valeur de l'en-tête de requête Referer si le paramètre pattern n'est pas inclus dans la requête. Type de données : string.
• Si le paramètre pattern est inclus dans la requête et que la requête correspond aux conditions de correspondance, la valeur true est renvoyée. Si aucune condition ne correspond, la valeur false est renvoyée.

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

• name : spécifie le nom du cookie.
• pattern : comparé aux conditions de correspondance. Les types de correspondance suivants sont pris en charge :
  • Algorithme de force brute : compare les valeurs selon un algorithme de force brute. Il s'agit du type de correspondance par défaut.
  • Expression régulière : compare les valeurs selon une expression régulière précédée de re:.

# 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')
}

• Si le paramètre pattern n'est pas inclus dans la requête
  • Le cookie spécifié existe : renvoie la valeur du cookie spécifié par le paramètre name sous forme de chaîne.
  • Le paramètre spécifié n'existe pas : renvoie la valeur false.
• Si le paramètre pattern est inclus dans la requête
  • Le paramètre spécifié existe : renvoie la valeur true si la valeur correspond aux conditions de correspondance. Sinon, la valeur false est renvoyée.
  • Le paramètre spécifié n'existe pas : renvoie la valeur false.

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

• Algorithme de force brute : compare les valeurs selon un algorithme de force brute. Il s'agit du type de correspondance par défaut.
• Expression régulière : compare les valeurs selon une expression régulière précédée de re:.

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

• Renvoie la première adresse de l'en-tête de requête X-Forwarded-For si le paramètre pattern n'est pas inclus dans la requête. Type de données : string.
• Si le paramètre pattern est inclus dans la requête et que la requête correspond aux conditions de correspondance, la valeur true est renvoyée. Si aucune condition ne correspond, la valeur false est renvoyée.

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

• name : spécifie le nom de l'en-tête de requête.

  Remplacez les traits d'union (-) dans l'en-tête de requête par des underscores (_). Par exemple, X-USER-ID doit être remplacé par x_user_id.

• pattern : comparé aux conditions de correspondance. Les types de correspondance suivants sont pris en charge :
  • Algorithme de force brute : compare les valeurs selon un algorithme de force brute. Il s'agit du type de correspondance par défaut.
  • Expression régulière : compare les valeurs selon une expression régulière précédée de re:.

# 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')
}

• Si le paramètre pattern n'est pas inclus dans la requête
  • L'en-tête de requête spécifié existe : renvoie la valeur de l'en-tête de requête spécifié par le paramètre name sous forme de chaîne.
  • Le paramètre spécifié n'existe pas : renvoie la valeur false.
• Si le paramètre pattern est inclus dans la requête
  • Le paramètre spécifié existe : renvoie la valeur true si la valeur correspond aux conditions de correspondance. Sinon, la valeur false est renvoyée.
  • Le paramètre spécifié n'existe pas : renvoie la valeur false.

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
say(concat('req_id: ', req_id()))