aliyun · yangzong18 · Mar 29, 2023
diff --git a/samples/BucketReferer.php b/samples/BucketReferer.php
@@ -14,13 +14,29 @@
 // Set referer whitelist
 $refererConfig = new RefererConfig();
 $refererConfig->setAllowEmptyReferer(true);
+$refererConfig->setAllowTruncateQueryString(false);
 $refererConfig->addReferer("www.aliiyun.com");
 $refererConfig->addReferer("www.aliiyuncs.com");
+
+$refererConfig->addBlackReferer("www.refuse.com");
+$refererConfig->addBlackReferer("www.?.deny.com");
 $ossClient->putBucketReferer($bucket, $refererConfig);
 Common::println("bucket $bucket refererConfig created:" . $refererConfig->serializeToXml());
 // Get referer whitelist
 $refererConfig = $ossClient->getBucketReferer($bucket);
-Common::println("bucket $bucket refererConfig fetched:" . $refererConfig->serializeToXml());
+
+Common::println("bucket $bucket referer allow empty referer:" . $refererConfig->getAllowEmptyReferer());
+Common::println("bucket $bucket referer allow truncate query string:" . $refererConfig->getAllowTruncateQueryString());
+if (count($refererConfig->getRefererList()) > 0){
+    foreach ($refererConfig->getRefererList() as $referer){
+        Common::println("bucket $bucket referer list:" . $referer);
+    }
+}
+if ($refererConfig->getRefererBlacklist() != null){
+    foreach ($refererConfig->getRefererBlacklist() as $referer){
+        Common::println("bucket $bucket referer blacklist:" . $referer);
+    }
+}
 
 // Delete referrer whitelist
 $refererConfig = new RefererConfig();
@@ -33,7 +49,6 @@
 putBucketReferer($ossClient, $bucket);
 getBucketReferer($ossClient, $bucket);
 deleteBucketReferer($ossClient, $bucket);
-getBucketReferer($ossClient, $bucket);
 
 /**
  * Set bucket referer configuration
@@ -48,6 +63,8 @@ function putBucketReferer($ossClient, $bucket)
     $refererConfig->setAllowEmptyReferer(true);
     $refererConfig->addReferer("www.aliiyun.com");
     $refererConfig->addReferer("www.aliiyuncs.com");
+    $refererConfig->addBlackReferer("www.refuse.com");
+    $refererConfig->addBlackReferer("www.?.deny.com");
     try {
         $ossClient->putBucketReferer($bucket, $refererConfig);
     } catch (OssException $e) {
@@ -67,9 +84,20 @@ function putBucketReferer($ossClient, $bucket)
  */
 function getBucketReferer($ossClient, $bucket)
 {
-    $refererConfig = null;
     try {
         $refererConfig = $ossClient->getBucketReferer($bucket);
+        Common::println("bucket $bucket referer allow empty referer:" . $refererConfig->getAllowEmptyReferer());
+        Common::println("bucket $bucket referer allow truncate query string:" . $refererConfig->getAllowTruncateQueryString());
+        if (count($refererConfig->getRefererList()) > 0){
+            foreach ($refererConfig->getRefererList() as $referer){
+                Common::println("bucket $bucket referer list:" . $referer);
+            }
+        }
+        if ($refererConfig->getRefererBlacklist() != null){
+            foreach ($refererConfig->getRefererBlacklist() as $referer){
+                Common::println("bucket $bucket referer blacklist:" . $referer);
+            }
+        }
     } catch (OssException $e) {
         printf(__FUNCTION__ . ": FAILED\n");
         printf($e->getMessage() . "\n");

diff --git a/src/OSS/Model/RefererConfig.php b/src/OSS/Model/RefererConfig.php
@@ -19,12 +19,19 @@ public function parseFromXml($strXml)
         $xml = simplexml_load_string($strXml);
         if (!isset($xml->AllowEmptyReferer)) return;
         if (!isset($xml->RefererList)) return;
-        $this->allowEmptyReferer =
-            (strval($xml->AllowEmptyReferer) === 'TRUE' || strval($xml->AllowEmptyReferer) === 'true') ? true : false;
-
+        $this->allowEmptyReferer = strval($xml->AllowEmptyReferer) === 'TRUE' || strval($xml->AllowEmptyReferer) === 'true';
+        if (isset($xml->AllowTruncateQueryString)){
+            $this->allowTruncateQueryString = strval($xml->AllowTruncateQueryString) === 'TRUE' || strval($xml->AllowTruncateQueryString) === 'true';
+        }
         foreach ($xml->RefererList->Referer as $key => $refer) {
             $this->refererList[] = strval($refer);
         }
+
+        if (isset($xml->RefererBlacklist->Referer)){
+            foreach ($xml->RefererBlacklist->Referer as $refer) {
+                $this->refererBlacklist[] = strval($refer);
+            }
+        }
     }
 
 
@@ -36,15 +43,22 @@ public function parseFromXml($strXml)
     public function serializeToXml()
     {
         $xml = new \SimpleXMLElement('<?xml version="1.0" encoding="utf-8"?><RefererConfiguration></RefererConfiguration>');
-        if ($this->allowEmptyReferer) {
-            $xml->addChild('AllowEmptyReferer', 'true');
-        } else {
-            $xml->addChild('AllowEmptyReferer', 'false');
+        if (isset($this->allowEmptyReferer)){
+            $xml->addChild('AllowEmptyReferer',json_encode($this->allowEmptyReferer));
+        }
+        if (isset($this->allowTruncateQueryString)){
+            $xml->addChild('AllowTruncateQueryString',json_encode($this->allowTruncateQueryString));
         }
         $refererList = $xml->addChild('RefererList');
         foreach ($this->refererList as $referer) {
             $refererList->addChild('Referer', $referer);
         }
+        if (isset($this->refererBlacklist)){
+            $refererList = $xml->addChild('RefererBlacklist');
+            foreach ($this->refererBlacklist as $referer) {
+                $refererList->addChild('Referer', $referer);
+            }
+        }
         return $xml->asXML();
     }
 
@@ -64,6 +78,14 @@ public function setAllowEmptyReferer($allowEmptyReferer)
         $this->allowEmptyReferer = $allowEmptyReferer;
     }
 
+    /**
+     * @param boolean $allowTruncateQueryString
+     */
+    public function setAllowTruncateQueryString($allowTruncateQueryString)
+    {
+        $this->allowTruncateQueryString = $allowTruncateQueryString;
+    }
+
     /**
      * @param string $referer
      */
@@ -72,14 +94,29 @@ public function addReferer($referer)
         $this->refererList[] = $referer;
     }
 
+    /**
+     * @param string $referer
+     */
+    public function addBlackReferer($referer){
+        $this->refererBlacklist[] = $referer;
+    }
+
     /**
      * @return boolean
      */
-    public function isAllowEmptyReferer()
+    public function getAllowEmptyReferer()
     {
         return $this->allowEmptyReferer;
     }
 
+
+    /**
+     * @return bool
+     */
+    public function getAllowTruncateQueryString(){
+        return $this->allowTruncateQueryString;
+    }
+
     /**
      * @return array
      */
@@ -88,6 +125,28 @@ public function getRefererList()
         return $this->refererList;
     }
 
+    /**
+     * @return array
+     */
+    public function getRefererBlacklist()
+    {
+        return $this->refererBlacklist;
+    }
+
+    /**
+     * @var bool
+     */
     private $allowEmptyReferer = true;
+    /**
+     * @var bool
+     */
+    private $allowTruncateQueryString;
+    /**
+     * @var array
+     */
     private $refererList = array();
+    /**
+     * @var array
+     */
+    private $refererBlacklist;
 }
diff --git a/src/OSS/OssClient.php b/src/OSS/OssClient.php
@@ -1064,7 +1064,7 @@ public function deleteBucketLifecycle($bucket, $options = NULL)
      * @param string $bucket bucket name
      * @param RefererConfig $refererConfig
      * @param array $options
-     * @return ResponseCore
+     * @return ResponseCore|null
      * @throws null
      */
     public function putBucketReferer($bucket, $refererConfig, $options = NULL)
@@ -1087,8 +1087,8 @@ public function putBucketReferer($bucket, $refererConfig, $options = NULL)
      *
      * @param string $bucket bucket name
      * @param array $options
-     * @throws OssException
-     * @return RefererConfig
+     * @return RefererConfig|null
+     * @throws OssException|RequestCore_Exception
      */
     public function getBucketReferer($bucket, $options = NULL)
     {

diff --git a/tests/OSS/Tests/GetRefererResultTest.php b/tests/OSS/Tests/GetRefererResultTest.php
@@ -20,6 +20,34 @@ class GetRefererResultTest extends \PHPUnit\Framework\TestCase
 <Referer>https://www.?.aliyuncs.com</Referer>
 </RefererList>
 </RefererConfiguration>
+BBBB;
+
+    private $validXml1 = <<<BBBB
+<?xml version="1.0" encoding="UTF-8"?>
+<RefererConfiguration>
+<AllowEmptyReferer>true</AllowEmptyReferer>
+<RefererList/>
+</RefererConfiguration>
+BBBB;
+
+    private $validXml2 = <<<BBBB
+<?xml version="1.0" encoding="UTF-8"?>
+<RefererConfiguration>
+<AllowEmptyReferer>false</AllowEmptyReferer>
+<AllowTruncateQueryString>false</AllowTruncateQueryString>
+<RefererList>
+<Referer>http://www.aliyun.com</Referer>
+<Referer>https://www.aliyun.com</Referer>
+<Referer>http://www.*.com</Referer>
+<Referer>https://www.?.aliyuncs.com</Referer>
+</RefererList>
+<RefererBlacklist>
+<Referer>http://www.refuse.com</Referer>
+<Referer>https://*.hack.com</Referer>
+<Referer>http://ban.*.com</Referer>
+<Referer>https://www.?.deny.com</Referer>
+</RefererBlacklist>
+</RefererConfiguration>
 BBBB;
 
     public function testParseValidXml()
@@ -30,7 +58,63 @@ public function testParseValidXml()
         $this->assertNotNull($result->getData());
         $this->assertNotNull($result->getRawResponse());
         $refererConfig = $result->getData();
-        $this->assertEquals($this->cleanXml($this->validXml), $this->cleanXml($refererConfig->serializeToXml()));
+
+        $this->assertTrue($refererConfig->getAllowEmptyReferer());
+        $refererList = $refererConfig->getRefererList();
+
+        $this->assertEquals(count($refererList),4);
+        $this->assertEquals($refererList[0],"http://www.aliyun.com");
+        $this->assertEquals($refererList[1],"https://www.aliyun.com");
+        $this->assertEquals($refererList[2],"http://www.*.com");
+        $this->assertEquals($refererList[3],"https://www.?.aliyuncs.com");
+
+    }
+
+    public function testParseValidXml1()
+    {
+        $response = new ResponseCore(array(), $this->validXml1, 200);
+        $result = new GetRefererResult($response);
+        $this->assertTrue($result->isOK());
+        $this->assertNotNull($result->getData());
+        $this->assertNotNull($result->getRawResponse());
+        $refererConfig = $result->getData();
+
+        $this->assertTrue($refererConfig->getAllowEmptyReferer());
+        $refererList = $refererConfig->getRefererList();
+        $this->assertEquals(count($refererList),0);
+
+        $this->assertNull($refererConfig->getAllowTruncateQueryString());
+        $this->assertNull($refererConfig->getRefererBlacklist());
+    }
+
+    public function testParseValidXml2()
+    {
+        $response = new ResponseCore(array(), $this->validXml2, 200);
+        $result = new GetRefererResult($response);
+        $this->assertTrue($result->isOK());
+        $this->assertNotNull($result->getData());
+        $this->assertNotNull($result->getRawResponse());
+        $refererConfig = $result->getData();
+        $this->assertFalse($refererConfig->getAllowEmptyReferer());
+        $this->assertFalse($refererConfig->getAllowTruncateQueryString());
+        $refererList = $refererConfig->getRefererList();
+
+        $this->assertEquals(count($refererList),4);
+        $this->assertEquals($refererList[0],"http://www.aliyun.com");
+        $this->assertEquals($refererList[1],"https://www.aliyun.com");
+        $this->assertEquals($refererList[2],"http://www.*.com");
+        $this->assertEquals($refererList[3],"https://www.?.aliyuncs.com");
+
+        $blacklist = $refererConfig->getRefererBlacklist();
+
+        $this->assertEquals(count($blacklist),4);
+        $this->assertEquals($blacklist[0],"http://www.refuse.com");
+        $this->assertEquals($blacklist[1],"https://*.hack.com");
+        $this->assertEquals($blacklist[2],"http://ban.*.com");
+        $this->assertEquals($blacklist[3],"https://www.?.deny.com");
+
+
+
     }
 
     private function cleanXml($xml)

diff --git a/tests/OSS/Tests/OssClientBucketRefererTest.php b/tests/OSS/Tests/OssClientBucketRefererTest.php
@@ -25,6 +25,7 @@ public function testBucket()
         try {
             Common::waitMetaSync();
             $refererConfig2 = $this->ossClient->getBucketReferer($this->bucket);
+            $refererConfig->setAllowTruncateQueryString(true);
             $this->assertEquals($refererConfig->serializeToXml(), $refererConfig2->serializeToXml());
         } catch (OssException $e) {
             $this->assertTrue(false);
@@ -45,4 +46,74 @@ public function testBucket()
             $this->assertTrue(false);
         }
     }
+
+    public function testBucketReferer()
+    {
+
+        try {
+            $referer = $this->ossClient->getBucketReferer($this->bucket);
+        } catch (OssException $e) {
+            $this->assertTrue(false);
+        }
+
+        $refererConfig = new RefererConfig();
+        $refererConfig->addReferer('http://www.aliyun.com');
+
+        try {
+            $this->ossClient->putBucketReferer($this->bucket, $refererConfig);
+        } catch (OssException $e) {
+            var_dump($e->getMessage());
+            $this->assertTrue(false);
+        }
+        try {
+            Common::waitMetaSync();
+            $refererConfig2 = $this->ossClient->getBucketReferer($this->bucket);
+            $refererConfig->setAllowTruncateQueryString(true);
+            $this->assertEquals($refererConfig->serializeToXml(), $refererConfig2->serializeToXml());
+        } catch (OssException $e) {
+            $this->assertTrue(false);
+        }
+
+        try {
+            Common::waitMetaSync();
+            $nullRefererConfig = new RefererConfig();
+            $nullRefererConfig->setAllowEmptyReferer(false);
+            $nullRefererConfig->setAllowTruncateQueryString(false);
+            $nullRefererConfig->addReferer('http://www.aliyun.com');
+
+            $nullRefererConfig->addBlackReferer('http://www.refuse.com');
+            $nullRefererConfig->addBlackReferer('https://www.refuse.com');
+            $this->ossClient->putBucketReferer($this->bucket, $nullRefererConfig);
+        } catch (OssException $e) {
+            $this->assertTrue(false);
+        }
+
+        try {
+            Common::waitMetaSync();
+            $refererConfig3 = $this->ossClient->getBucketReferer($this->bucket);
+            $this->assertEquals($refererConfig3->serializeToXml(), $nullRefererConfig->serializeToXml());
+        } catch (OssException $e) {
+            $this->assertTrue(false);
+        }
+
+
+        try {
+            Common::waitMetaSync();
+            $refererConfig4 = new RefererConfig();
+            $this->ossClient->putBucketReferer($this->bucket,$refererConfig4);
+        } catch (OssException $e) {
+            $this->assertTrue(false);
+        }
+
+
+        try {
+            Common::waitMetaSync();
+            $refererConfig5 = $this->ossClient->getBucketReferer($this->bucket);
+            $this->assertEquals($referer->serializeToXml(), $refererConfig5->serializeToXml());
+        } catch (OssException $e) {
+            $this->assertTrue(false);
+        }
+
+
+    }
 }