diff --git a/trunk/src/protocol/srs_protocol_amf0.cpp b/trunk/src/protocol/srs_protocol_amf0.cpp
index 343d0e0e7..135632996 100644
--- a/trunk/src/protocol/srs_protocol_amf0.cpp
+++ b/trunk/src/protocol/srs_protocol_amf0.cpp
@@ -383,25 +383,22 @@ SrsAmf0Any* SrsAmf0Any::date(int64_t value)
     return new SrsAmf0Date(value);
 }
 
-int SrsAmf0Any::discovery(SrsBuffer* stream, SrsAmf0Any** ppvalue)
+srs_error_t SrsAmf0Any::discovery(SrsBuffer* stream, SrsAmf0Any** ppvalue)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // detect the object-eof specially
     if (srs_amf0_is_object_eof(stream)) {
         *ppvalue = new SrsAmf0ObjectEOF();
-        return ret;
+        return err;
     }
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read any marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "marker requires 1 only %d bytes", stream->left());
     }
     
     char marker = stream->read_1bytes();
-    srs_verbose("amf0 any marker success");
     
     // backward the 1byte marker.
     stream->skip(-1);
@@ -409,45 +406,43 @@ int SrsAmf0Any::discovery(SrsBuffer* stream, SrsAmf0Any** ppvalue)
     switch (marker) {
         case RTMP_AMF0_String: {
             *ppvalue = SrsAmf0Any::str();
-            return ret;
+            return err;
         }
         case RTMP_AMF0_Boolean: {
             *ppvalue = SrsAmf0Any::boolean();
-            return ret;
+            return err;
         }
         case RTMP_AMF0_Number: {
             *ppvalue = SrsAmf0Any::number();
-            return ret;
+            return err;
         }
         case RTMP_AMF0_Null: {
             *ppvalue = SrsAmf0Any::null();
-            return ret;
+            return err;
         }
         case RTMP_AMF0_Undefined: {
             *ppvalue = SrsAmf0Any::undefined();
-            return ret;
+            return err;
         }
         case RTMP_AMF0_Object: {
             *ppvalue = SrsAmf0Any::object();
-            return ret;
+            return err;
         }
         case RTMP_AMF0_EcmaArray: {
             *ppvalue = SrsAmf0Any::ecma_array();
-            return ret;
+            return err;
         }
         case RTMP_AMF0_StrictArray: {
             *ppvalue = SrsAmf0Any::strict_array();
-            return ret;
+            return err;
         }
         case RTMP_AMF0_Date: {
             *ppvalue = SrsAmf0Any::date();
-            return ret;
+            return err;
         }
         case RTMP_AMF0_Invalid:
         default: {
-            ret = ERROR_RTMP_AMF0_INVALID;
-            srs_error("invalid amf0 message type. marker=%#x, ret=%d", marker, ret);
-            return ret;
+            return srs_error_new(ERROR_RTMP_AMF0_INVALID, "invalid amf0 message, marker=%#x", marker);
         }
     }
 }
@@ -608,69 +603,50 @@ int SrsAmf0ObjectEOF::total_size()
     return SrsAmf0Size::object_eof();
 }
 
-int SrsAmf0ObjectEOF::read(SrsBuffer* stream)
+srs_error_t SrsAmf0ObjectEOF::read(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // value
     if (!stream->require(2)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read object eof value failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "EOF requires 2 only %d bytes", stream->left());
     }
     int16_t temp = stream->read_2bytes();
     if (temp != 0x00) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read object eof value check failed. "
-                  "must be 0x00, actual is %#x, ret=%d", temp, ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "EOF invalid marker=%#x", temp);
     }
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read object eof marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "EOF requires 1 only %d bytes", stream->left());
     }
     
     char marker = stream->read_1bytes();
     if (marker != RTMP_AMF0_ObjectEnd) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 check object eof marker failed. "
-                  "marker=%#x, required=%#x, ret=%d", marker, RTMP_AMF0_ObjectEnd, ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "EOF invalid marker=%#x", marker);
     }
-    srs_verbose("amf0 read object eof marker success");
     
-    srs_verbose("amf0 read object eof success");
-    
-    return ret;
+    return err;
 }
-int SrsAmf0ObjectEOF::write(SrsBuffer* stream)
+
+srs_error_t SrsAmf0ObjectEOF::write(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // value
     if (!stream->require(2)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write object eof value failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "EOF requires 2 only %d bytes", stream->left());
     }
     stream->write_2bytes(0x00);
-    srs_verbose("amf0 write object eof value success");
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write object eof marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "EOF requires 1 only %d bytes", stream->left());
     }
     
     stream->write_1bytes(RTMP_AMF0_ObjectEnd);
     
-    srs_verbose("amf0 read object eof success");
-    
-    return ret;
+    return err;
 }
 
 SrsAmf0Any* SrsAmf0ObjectEOF::copy()
@@ -708,101 +684,80 @@ int SrsAmf0Object::total_size()
     return size;
 }
 
-int SrsAmf0Object::read(SrsBuffer* stream)
+srs_error_t SrsAmf0Object::read(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read object marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "object requires 1 only %d bytes", stream->left());
     }
     
     char marker = stream->read_1bytes();
     if (marker != RTMP_AMF0_Object) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 check object marker failed. "
-                  "marker=%#x, required=%#x, ret=%d", marker, RTMP_AMF0_Object, ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "object invalid marker=%#x", marker);
     }
-    srs_verbose("amf0 read object marker success");
     
     // value
     while (!stream->empty()) {
         // detect whether is eof.
         if (srs_amf0_is_object_eof(stream)) {
             SrsAmf0ObjectEOF pbj_eof;
-            if ((ret = pbj_eof.read(stream)) != ERROR_SUCCESS) {
-                srs_error("amf0 object read eof failed. ret=%d", ret);
-                return ret;
+            if ((err = pbj_eof.read(stream)) != srs_success) {
+                return srs_error_wrap(err, "read EOF");
             }
-            srs_info("amf0 read object EOF.");
             break;
         }
         
         // property-name: utf8 string
         std::string property_name;
-        if ((ret = srs_amf0_read_utf8(stream, property_name)) != ERROR_SUCCESS) {
-            srs_error("amf0 object read property name failed. ret=%d", ret);
-            return ret;
+        if ((err = srs_amf0_read_utf8(stream, property_name)) != srs_success) {
+            return srs_error_wrap(err, "read property name");
         }
         // property-value: any
         SrsAmf0Any* property_value = NULL;
-        if ((ret = srs_amf0_read_any(stream, &property_value)) != ERROR_SUCCESS) {
-            srs_error("amf0 object read property_value failed. "
-                      "name=%s, ret=%d", property_name.c_str(), ret);
+        if ((err = srs_amf0_read_any(stream, &property_value)) != srs_success) {
             srs_freep(property_value);
-            return ret;
+            return srs_error_wrap(err, "read property value, name=%s", property_name.c_str());
         }
         
         // add property
         this->set(property_name, property_value);
     }
     
-    return ret;
+    return err;
 }
 
-int SrsAmf0Object::write(SrsBuffer* stream)
+srs_error_t SrsAmf0Object::write(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write object marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "object requires 1 only %d bytes", stream->left());
     }
     
     stream->write_1bytes(RTMP_AMF0_Object);
-    srs_verbose("amf0 write object marker success");
     
     // value
     for (int i = 0; i < properties->count(); i++) {
         std::string name = this->key_at(i);
         SrsAmf0Any* any = this->value_at(i);
         
-        if ((ret = srs_amf0_write_utf8(stream, name)) != ERROR_SUCCESS) {
-            srs_error("write object property name failed. ret=%d", ret);
-            return ret;
+        if ((err = srs_amf0_write_utf8(stream, name)) != srs_success) {
+            return srs_error_wrap(err, "write property name=%s", name.c_str());
         }
         
-        if ((ret = srs_amf0_write_any(stream, any)) != ERROR_SUCCESS) {
-            srs_error("write object property value failed. ret=%d", ret);
-            return ret;
+        if ((err = srs_amf0_write_any(stream, any)) != srs_success) {
+            return srs_error_wrap(err, "write property value, name=%s", name.c_str());
         }
-        
-        srs_verbose("write amf0 property success. name=%s", name.c_str());
     }
     
-    if ((ret = eof->write(stream)) != ERROR_SUCCESS) {
-        srs_error("write object eof failed. ret=%d", ret);
-        return ret;
+    if ((err = eof->write(stream)) != srs_success) {
+        return srs_error_wrap(err, "write EOF");
     }
     
-    srs_verbose("write amf0 object success.");
-    
-    return ret;
+    return err;
 }
 
 SrsAmf0Any* SrsAmf0Object::copy()
@@ -907,35 +862,26 @@ int SrsAmf0EcmaArray::total_size()
     return size;
 }
 
-int SrsAmf0EcmaArray::read(SrsBuffer* stream)
+srs_error_t SrsAmf0EcmaArray::read(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read ecma_array marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires 1 only %d bytes", stream->left());
     }
     
     char marker = stream->read_1bytes();
     if (marker != RTMP_AMF0_EcmaArray) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 check ecma_array marker failed. "
-                  "marker=%#x, required=%#x, ret=%d", marker, RTMP_AMF0_EcmaArray, ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "EcmaArray invalid marker=%#x", marker);
     }
-    srs_verbose("amf0 read ecma_array marker success");
     
     // count
     if (!stream->require(4)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read ecma_array count failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires 4 only %d bytes", stream->left());
     }
     
     int32_t count = stream->read_4bytes();
-    srs_verbose("amf0 read ecma_array count success. count=%d", count);
     
     // value
     this->_count = count;
@@ -944,84 +890,67 @@ int SrsAmf0EcmaArray::read(SrsBuffer* stream)
         // detect whether is eof.
         if (srs_amf0_is_object_eof(stream)) {
             SrsAmf0ObjectEOF pbj_eof;
-            if ((ret = pbj_eof.read(stream)) != ERROR_SUCCESS) {
-                srs_error("amf0 ecma_array read eof failed. ret=%d", ret);
-                return ret;
+            if ((err = pbj_eof.read(stream)) != srs_success) {
+                return srs_error_wrap(err, "read EOF");
             }
-            srs_info("amf0 read ecma_array EOF.");
             break;
         }
         
         // property-name: utf8 string
         std::string property_name;
-        if ((ret =srs_amf0_read_utf8(stream, property_name)) != ERROR_SUCCESS) {
-            srs_error("amf0 ecma_array read property name failed. ret=%d", ret);
-            return ret;
+        if ((err =srs_amf0_read_utf8(stream, property_name)) != srs_success) {
+            return srs_error_wrap(err, "read property name");
         }
         // property-value: any
         SrsAmf0Any* property_value = NULL;
-        if ((ret = srs_amf0_read_any(stream, &property_value)) != ERROR_SUCCESS) {
-            srs_error("amf0 ecma_array read property_value failed. "
-                      "name=%s, ret=%d", property_name.c_str(), ret);
-            return ret;
+        if ((err = srs_amf0_read_any(stream, &property_value)) != srs_success) {
+            return srs_error_wrap(err, "read property value, name=%s", property_name.c_str());
         }
         
         // add property
         this->set(property_name, property_value);
     }
     
-    return ret;
+    return err;
 }
-int SrsAmf0EcmaArray::write(SrsBuffer* stream)
+
+srs_error_t SrsAmf0EcmaArray::write(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write ecma_array marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 1 only %d bytes", stream->left());
     }
     
     stream->write_1bytes(RTMP_AMF0_EcmaArray);
-    srs_verbose("amf0 write ecma_array marker success");
     
     // count
     if (!stream->require(4)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write ecma_array count failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 4 only %d bytes", stream->left());
     }
     
     stream->write_4bytes(this->_count);
-    srs_verbose("amf0 write ecma_array count success. count=%d", _count);
     
     // value
     for (int i = 0; i < properties->count(); i++) {
         std::string name = this->key_at(i);
         SrsAmf0Any* any = this->value_at(i);
         
-        if ((ret = srs_amf0_write_utf8(stream, name)) != ERROR_SUCCESS) {
-            srs_error("write ecma_array property name failed. ret=%d", ret);
-            return ret;
+        if ((err = srs_amf0_write_utf8(stream, name)) != srs_success) {
+            return srs_error_wrap(err, "write property name=%s", name.c_str());
         }
         
-        if ((ret = srs_amf0_write_any(stream, any)) != ERROR_SUCCESS) {
-            srs_error("write ecma_array property value failed. ret=%d", ret);
-            return ret;
+        if ((err = srs_amf0_write_any(stream, any)) != srs_success) {
+            return srs_error_wrap(err, "write property value, name=%s", name.c_str());
         }
-        
-        srs_verbose("write amf0 property success. name=%s", name.c_str());
     }
     
-    if ((ret = eof->write(stream)) != ERROR_SUCCESS) {
-        srs_error("write ecma_array eof failed. ret=%d", ret);
-        return ret;
+    if ((err = eof->write(stream)) != srs_success) {
+        return srs_error_wrap(err, "write EOF");
     }
     
-    srs_verbose("write ecma_array object success.");
-    
-    return ret;
+    return err;
 }
 
 SrsAmf0Any* SrsAmf0EcmaArray::copy()
@@ -1119,35 +1048,26 @@ int SrsAmf0StrictArray::total_size()
     return size;
 }
 
-int SrsAmf0StrictArray::read(SrsBuffer* stream)
+srs_error_t SrsAmf0StrictArray::read(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read strict_array marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires 1 only %d bytes", stream->left());
     }
     
     char marker = stream->read_1bytes();
     if (marker != RTMP_AMF0_StrictArray) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 check strict_array marker failed. "
-                  "marker=%#x, required=%#x, ret=%d", marker, RTMP_AMF0_StrictArray, ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "StrictArray invalid marker=%#x", marker);
     }
-    srs_verbose("amf0 read strict_array marker success");
     
     // count
     if (!stream->require(4)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read strict_array count failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires 4 only %d bytes", stream->left());
     }
     
     int32_t count = stream->read_4bytes();
-    srs_verbose("amf0 read strict_array count success. count=%d", count);
     
     // value
     this->_count = count;
@@ -1155,56 +1075,45 @@ int SrsAmf0StrictArray::read(SrsBuffer* stream)
     for (int i = 0; i < count && !stream->empty(); i++) {
         // property-value: any
         SrsAmf0Any* elem = NULL;
-        if ((ret = srs_amf0_read_any(stream, &elem)) != ERROR_SUCCESS) {
-            srs_error("amf0 strict_array read value failed. ret=%d", ret);
-            return ret;
+        if ((err = srs_amf0_read_any(stream, &elem)) != srs_success) {
+            return srs_error_wrap(err, "read property");
         }
         
         // add property
         properties.push_back(elem);
     }
     
-    return ret;
+    return err;
 }
-int SrsAmf0StrictArray::write(SrsBuffer* stream)
+
+srs_error_t SrsAmf0StrictArray::write(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write strict_array marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 1 only %d bytes", stream->left());
     }
     
     stream->write_1bytes(RTMP_AMF0_StrictArray);
-    srs_verbose("amf0 write strict_array marker success");
     
     // count
     if (!stream->require(4)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write strict_array count failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 4 only %d bytes", stream->left());
     }
     
     stream->write_4bytes(this->_count);
-    srs_verbose("amf0 write strict_array count success. count=%d", _count);
     
     // value
     for (int i = 0; i < (int)properties.size(); i++) {
         SrsAmf0Any* any = properties[i];
         
-        if ((ret = srs_amf0_write_any(stream, any)) != ERROR_SUCCESS) {
-            srs_error("write strict_array property value failed. ret=%d", ret);
-            return ret;
+        if ((err = srs_amf0_write_any(stream, any)) != srs_success) {
+            return srs_error_wrap(err, "write property");
         }
-        
-        srs_verbose("write amf0 property success.");
     }
     
-    srs_verbose("write strict_array object success.");
-    
-    return ret;
+    return err;
 }
 
 SrsAmf0Any* SrsAmf0StrictArray::copy()
@@ -1258,7 +1167,7 @@ void SrsAmf0StrictArray::append(SrsAmf0Any* any)
 
 int SrsAmf0Size::utf8(string value)
 {
-    return 2 + value.length();
+    return 2 + (int)value.length();
 }
 
 int SrsAmf0Size::str(string value)
@@ -1349,12 +1258,12 @@ int SrsAmf0String::total_size()
     return SrsAmf0Size::str(value);
 }
 
-int SrsAmf0String::read(SrsBuffer* stream)
+srs_error_t SrsAmf0String::read(SrsBuffer* stream)
 {
     return srs_amf0_read_string(stream, value);
 }
 
-int SrsAmf0String::write(SrsBuffer* stream)
+srs_error_t SrsAmf0String::write(SrsBuffer* stream)
 {
     return srs_amf0_write_string(stream, value);
 }
@@ -1380,12 +1289,12 @@ int SrsAmf0Boolean::total_size()
     return SrsAmf0Size::boolean();
 }
 
-int SrsAmf0Boolean::read(SrsBuffer* stream)
+srs_error_t SrsAmf0Boolean::read(SrsBuffer* stream)
 {
     return srs_amf0_read_boolean(stream, value);
 }
 
-int SrsAmf0Boolean::write(SrsBuffer* stream)
+srs_error_t SrsAmf0Boolean::write(SrsBuffer* stream)
 {
     return srs_amf0_write_boolean(stream, value);
 }
@@ -1411,12 +1320,12 @@ int SrsAmf0Number::total_size()
     return SrsAmf0Size::number();
 }
 
-int SrsAmf0Number::read(SrsBuffer* stream)
+srs_error_t SrsAmf0Number::read(SrsBuffer* stream)
 {
     return srs_amf0_read_number(stream, value);
 }
 
-int SrsAmf0Number::write(SrsBuffer* stream)
+srs_error_t SrsAmf0Number::write(SrsBuffer* stream)
 {
     return srs_amf0_write_number(stream, value);
 }
@@ -1443,38 +1352,29 @@ int SrsAmf0Date::total_size()
     return SrsAmf0Size::date();
 }
 
-int SrsAmf0Date::read(SrsBuffer* stream)
+srs_error_t SrsAmf0Date::read(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read date marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires 1 only %d bytes", stream->left());
     }
     
     char marker = stream->read_1bytes();
     if (marker != RTMP_AMF0_Date) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 check date marker failed. "
-                  "marker=%#x, required=%#x, ret=%d", marker, RTMP_AMF0_Date, ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "Date invalid marker=%#x", marker);
     }
-    srs_verbose("amf0 read date marker success");
     
     // date value
     // An ActionScript Date is serialized as the number of milliseconds
     // elapsed since the epoch of midnight on 1st Jan 1970 in the UTC
     // time zone.
     if (!stream->require(8)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read date failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires 8 only %d bytes", stream->left());
     }
     
     _date_value = stream->read_8bytes();
-    srs_verbose("amf0 read date success. date=%" PRId64, _date_value);
     
     // time zone
     // While the design of this type reserves room for time zone offset
@@ -1482,53 +1382,40 @@ int SrsAmf0Date::read(SrsBuffer* stream)
     // to change time zones when serializing dates on a network. It is suggested
     // that the time zone be queried independently as needed.
     if (!stream->require(2)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read time zone failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires 2 only %d bytes", stream->left());
     }
     
     _time_zone = stream->read_2bytes();
-    srs_verbose("amf0 read time zone success. zone=%d", _time_zone);
     
-    return ret;
+    return err;
 }
-int SrsAmf0Date::write(SrsBuffer* stream)
+
+srs_error_t SrsAmf0Date::write(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write date marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 1 only %d bytes", stream->left());
     }
     
     stream->write_1bytes(RTMP_AMF0_Date);
-    srs_verbose("amf0 write date marker success");
     
     // date value
     if (!stream->require(8)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write date failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 8 only %d bytes", stream->left());
     }
     
     stream->write_8bytes(_date_value);
-    srs_verbose("amf0 write date success. date=%" PRId64, _date_value);
     
     // time zone
     if (!stream->require(2)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write time zone failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 2 only %d bytes", stream->left());
     }
     
     stream->write_2bytes(_time_zone);
-    srs_verbose("amf0 write time zone success. date=%d", _time_zone);
     
-    srs_verbose("write date object success.");
-    
-    return ret;
+    return err;
 }
 
 SrsAmf0Any* SrsAmf0Date::copy()
@@ -1565,12 +1452,12 @@ int SrsAmf0Null::total_size()
     return SrsAmf0Size::null();
 }
 
-int SrsAmf0Null::read(SrsBuffer* stream)
+srs_error_t SrsAmf0Null::read(SrsBuffer* stream)
 {
     return srs_amf0_read_null(stream);
 }
 
-int SrsAmf0Null::write(SrsBuffer* stream)
+srs_error_t SrsAmf0Null::write(SrsBuffer* stream)
 {
     return srs_amf0_write_null(stream);
 }
@@ -1595,12 +1482,12 @@ int SrsAmf0Undefined::total_size()
     return SrsAmf0Size::undefined();
 }
 
-int SrsAmf0Undefined::read(SrsBuffer* stream)
+srs_error_t SrsAmf0Undefined::read(SrsBuffer* stream)
 {
     return srs_amf0_read_undefined(stream);
 }
 
-int SrsAmf0Undefined::write(SrsBuffer* stream)
+srs_error_t SrsAmf0Undefined::write(SrsBuffer* stream)
 {
     return srs_amf0_write_undefined(stream);
 }
@@ -1611,117 +1498,88 @@ SrsAmf0Any* SrsAmf0Undefined::copy()
     return copy;
 }
 
-int srs_amf0_read_any(SrsBuffer* stream, SrsAmf0Any** ppvalue)
+srs_error_t srs_amf0_read_any(SrsBuffer* stream, SrsAmf0Any** ppvalue)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
-    if ((ret = SrsAmf0Any::discovery(stream, ppvalue)) != ERROR_SUCCESS) {
-        srs_error("amf0 discovery any elem failed. ret=%d", ret);
-        return ret;
+    if ((err = SrsAmf0Any::discovery(stream, ppvalue)) != srs_success) {
+        return srs_error_wrap(err, "discovery");
     }
     
     srs_assert(*ppvalue);
     
-    if ((ret = (*ppvalue)->read(stream)) != ERROR_SUCCESS) {
-        srs_error("amf0 parse elem failed. ret=%d", ret);
+    if ((err = (*ppvalue)->read(stream)) != srs_success) {
         srs_freep(*ppvalue);
-        return ret;
+        return srs_error_wrap(err, "parse elem");
     }
     
-    return ret;
+    return err;
 }
 
-int srs_amf0_read_string(SrsBuffer* stream, string& value)
+srs_error_t srs_amf0_read_string(SrsBuffer* stream, string& value)
 {
-    int ret = ERROR_SUCCESS;
-    
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read string marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires 1 only %d bytes", stream->left());
     }
     
     char marker = stream->read_1bytes();
     if (marker != RTMP_AMF0_String) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 check string marker failed. "
-                  "marker=%#x, required=%#x, ret=%d", marker, RTMP_AMF0_String, ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "String invalid marker=%#x", marker);
     }
-    srs_verbose("amf0 read string marker success");
     
     return srs_amf0_read_utf8(stream, value);
 }
 
-int srs_amf0_write_string(SrsBuffer* stream, string value)
-{
-    int ret = ERROR_SUCCESS;
-    
+srs_error_t srs_amf0_write_string(SrsBuffer* stream, string value)
+{   
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write string marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 1 only %d bytes", stream->left());
     }
     
     stream->write_1bytes(RTMP_AMF0_String);
-    srs_verbose("amf0 write string marker success");
     
     return srs_amf0_write_utf8(stream, value);
 }
 
-int srs_amf0_read_boolean(SrsBuffer* stream, bool& value)
+srs_error_t srs_amf0_read_boolean(SrsBuffer* stream, bool& value)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read bool marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires 1 only %d bytes", stream->left());
     }
     
     char marker = stream->read_1bytes();
     if (marker != RTMP_AMF0_Boolean) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 check bool marker failed. "
-                  "marker=%#x, required=%#x, ret=%d", marker, RTMP_AMF0_Boolean, ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "Boolean invalid marker=%#x", marker);
     }
-    srs_verbose("amf0 read bool marker success");
     
     // value
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read bool value failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires 1 only %d bytes", stream->left());
     }
     
     value = (stream->read_1bytes() != 0);
     
-    srs_verbose("amf0 read bool value success. value=%d", value);
-    
-    return ret;
+    return err;
 }
-int srs_amf0_write_boolean(SrsBuffer* stream, bool value)
+
+srs_error_t srs_amf0_write_boolean(SrsBuffer* stream, bool value)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write bool marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 1 only %d bytes", stream->left());
     }
     stream->write_1bytes(RTMP_AMF0_Boolean);
-    srs_verbose("amf0 write bool marker success");
     
     // value
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write bool value failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 1 only %d bytes", stream->left());
     }
     
     if (value) {
@@ -1730,180 +1588,139 @@ int srs_amf0_write_boolean(SrsBuffer* stream, bool value)
         stream->write_1bytes(0x00);
     }
     
-    srs_verbose("amf0 write bool value success. value=%d", value);
-    
-    return ret;
+    return err;
 }
 
-int srs_amf0_read_number(SrsBuffer* stream, double& value)
+srs_error_t srs_amf0_read_number(SrsBuffer* stream, double& value)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read number marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires 1 only %d bytes", stream->left());
     }
     
     char marker = stream->read_1bytes();
     if (marker != RTMP_AMF0_Number) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 check number marker failed. "
-                  "marker=%#x, required=%#x, ret=%d", marker, RTMP_AMF0_Number, ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "Number invalid marker=%#x", marker);
     }
-    srs_verbose("amf0 read number marker success");
     
     // value
     if (!stream->require(8)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read number value failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires 8 only %d bytes", stream->left());
     }
     
     int64_t temp = stream->read_8bytes();
     memcpy(&value, &temp, 8);
     
-    srs_verbose("amf0 read number value success. value=%.2f", value);
-    
-    return ret;
+    return err;
 }
-int srs_amf0_write_number(SrsBuffer* stream, double value)
+
+srs_error_t srs_amf0_write_number(SrsBuffer* stream, double value)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write number marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 1 only %d bytes", stream->left());
     }
     
     stream->write_1bytes(RTMP_AMF0_Number);
-    srs_verbose("amf0 write number marker success");
     
     // value
     if (!stream->require(8)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write number value failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 8 only %d bytes", stream->left());
     }
     
     int64_t temp = 0x00;
     memcpy(&temp, &value, 8);
     stream->write_8bytes(temp);
     
-    srs_verbose("amf0 write number value success. value=%.2f", value);
-    
-    return ret;
+    return err;
 }
 
-int srs_amf0_read_null(SrsBuffer* stream)
+srs_error_t srs_amf0_read_null(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read null marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires 1 only %d bytes", stream->left());
     }
     
     char marker = stream->read_1bytes();
     if (marker != RTMP_AMF0_Null) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 check null marker failed. "
-                  "marker=%#x, required=%#x, ret=%d", marker, RTMP_AMF0_Null, ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "Null invalid marker=%#x", marker);
     }
-    srs_verbose("amf0 read null success");
     
-    return ret;
+    return err;
 }
-int srs_amf0_write_null(SrsBuffer* stream)
+
+srs_error_t srs_amf0_write_null(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write null marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 1 only %d bytes", stream->left());
     }
     
     stream->write_1bytes(RTMP_AMF0_Null);
-    srs_verbose("amf0 write null marker success");
     
-    return ret;
+    return err;
 }
 
-int srs_amf0_read_undefined(SrsBuffer* stream)
+srs_error_t srs_amf0_read_undefined(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 read undefined marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires 1 only %d bytes", stream->left());
     }
     
     char marker = stream->read_1bytes();
     if (marker != RTMP_AMF0_Undefined) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 check undefined marker failed. "
-                  "marker=%#x, required=%#x, ret=%d", marker, RTMP_AMF0_Undefined, ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "Undefined invalid marker=%#x", marker);
     }
-    srs_verbose("amf0 read undefined success");
     
-    return ret;
+    return err;
 }
-int srs_amf0_write_undefined(SrsBuffer* stream)
+
+srs_error_t srs_amf0_write_undefined(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // marker
     if (!stream->require(1)) {
-        ret = ERROR_RTMP_AMF0_ENCODE;
-        srs_error("amf0 write undefined marker failed. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 1 only %d bytes", stream->left());
     }
     
     stream->write_1bytes(RTMP_AMF0_Undefined);
-    srs_verbose("amf0 write undefined marker success");
     
-    return ret;
+    return err;
 }
 
-
 namespace _srs_internal
 {
-    int srs_amf0_read_utf8(SrsBuffer* stream, string& value)
+    srs_error_t srs_amf0_read_utf8(SrsBuffer* stream, string& value)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         // len
         if (!stream->require(2)) {
-            ret = ERROR_RTMP_AMF0_DECODE;
-            srs_error("amf0 read string length failed. ret=%d", ret);
-            return ret;
+            return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires 2 only %d bytes", stream->left());
         }
         int16_t len = stream->read_2bytes();
-        srs_verbose("amf0 read string length success. len=%d", len);
         
         // empty string
         if (len <= 0) {
-            srs_verbose("amf0 read empty string. ret=%d", ret);
-            return ret;
+            return err;
         }
         
         // data
         if (!stream->require(len)) {
-            ret = ERROR_RTMP_AMF0_DECODE;
-            srs_error("amf0 read string data failed. ret=%d", ret);
-            return ret;
+            return srs_error_new(ERROR_RTMP_AMF0_DECODE, "requires %d only %d bytes", len, stream->left());
         }
         std::string str = stream->read_string(len);
         
@@ -1921,39 +1738,32 @@ namespace _srs_internal
          }*/
         
         value = str;
-        srs_verbose("amf0 read string data success. str=%s", str.c_str());
         
-        return ret;
+        return err;
     }
-    int srs_amf0_write_utf8(SrsBuffer* stream, string value)
+    
+    srs_error_t srs_amf0_write_utf8(SrsBuffer* stream, string value)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         // len
         if (!stream->require(2)) {
-            ret = ERROR_RTMP_AMF0_ENCODE;
-            srs_error("amf0 write string length failed. ret=%d", ret);
-            return ret;
+            return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 2 only %d bytes", stream->left());
         }
         stream->write_2bytes(value.length());
-        srs_verbose("amf0 write string length success. len=%d", (int)value.length());
         
         // empty string
         if (value.length() <= 0) {
-            srs_verbose("amf0 write empty string. ret=%d", ret);
-            return ret;
+            return err;
         }
         
         // data
-        if (!stream->require(value.length())) {
-            ret = ERROR_RTMP_AMF0_ENCODE;
-            srs_error("amf0 write string data failed. ret=%d", ret);
-            return ret;
+        if (!stream->require((int)value.length())) {
+            return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires %d only %d bytes", value.length(), stream->left());
         }
         stream->write_string(value);
-        srs_verbose("amf0 write string data success. str=%s", value.c_str());
         
-        return ret;
+        return err;
     }
     
     bool srs_amf0_is_object_eof(SrsBuffer* stream)
@@ -1969,36 +1779,29 @@ namespace _srs_internal
         return false;
     }
     
-    int srs_amf0_write_object_eof(SrsBuffer* stream, SrsAmf0ObjectEOF* value)
+    srs_error_t srs_amf0_write_object_eof(SrsBuffer* stream, SrsAmf0ObjectEOF* value)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         srs_assert(value != NULL);
         
         // value
         if (!stream->require(2)) {
-            ret = ERROR_RTMP_AMF0_ENCODE;
-            srs_error("amf0 write object eof value failed. ret=%d", ret);
-            return ret;
+            return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 2 only %d bytes", stream->left());
         }
         stream->write_2bytes(0x00);
-        srs_verbose("amf0 write object eof value success");
         
         // marker
         if (!stream->require(1)) {
-            ret = ERROR_RTMP_AMF0_ENCODE;
-            srs_error("amf0 write object eof marker failed. ret=%d", ret);
-            return ret;
+            return srs_error_new(ERROR_RTMP_AMF0_ENCODE, "requires 1 only %d bytes", stream->left());
         }
         
         stream->write_1bytes(RTMP_AMF0_ObjectEnd);
         
-        srs_verbose("amf0 read object eof success");
-        
-        return ret;
+        return err;
     }
     
-    int srs_amf0_write_any(SrsBuffer* stream, SrsAmf0Any* value)
+    srs_error_t srs_amf0_write_any(SrsBuffer* stream, SrsAmf0Any* value)
     {
         srs_assert(value != NULL);
         return value->write(stream);
diff --git a/trunk/src/protocol/srs_protocol_amf0.hpp b/trunk/src/protocol/srs_protocol_amf0.hpp
index 07394c313..8f1e9de25 100644
--- a/trunk/src/protocol/srs_protocol_amf0.hpp
+++ b/trunk/src/protocol/srs_protocol_amf0.hpp
@@ -253,11 +253,11 @@ public:
     /**
      * read AMF0 instance from stream.
      */
-    virtual int read(SrsBuffer* stream) = 0;
+    virtual srs_error_t read(SrsBuffer* stream) = 0;
     /**
      * write AMF0 instance to stream.
      */
-    virtual int write(SrsBuffer* stream) = 0;
+    virtual srs_error_t write(SrsBuffer* stream) = 0;
     /**
      * copy current AMF0 instance.
      */
@@ -324,7 +324,7 @@ public:
      * @remark, instance is created without read from stream, user must
      *       use (*ppvalue)->read(stream) to get the instance.
      */
-    static int discovery(SrsBuffer* stream, SrsAmf0Any** ppvalue);
+    static srs_error_t discovery(SrsBuffer* stream, SrsAmf0Any** ppvalue);
 };
 
 /**
@@ -349,8 +349,8 @@ public:
     // serialize/deserialize to/from stream.
 public:
     virtual int total_size();
-    virtual int read(SrsBuffer* stream);
-    virtual int write(SrsBuffer* stream);
+    virtual srs_error_t read(SrsBuffer* stream);
+    virtual srs_error_t write(SrsBuffer* stream);
     virtual SrsAmf0Any* copy();
     /**
      * convert amf0 to json.
@@ -440,8 +440,8 @@ public:
     // serialize/deserialize to/from stream.
 public:
     virtual int total_size();
-    virtual int read(SrsBuffer* stream);
-    virtual int write(SrsBuffer* stream);
+    virtual srs_error_t read(SrsBuffer* stream);
+    virtual srs_error_t write(SrsBuffer* stream);
     virtual SrsAmf0Any* copy();
     /**
      * convert amf0 to json.
@@ -525,8 +525,8 @@ public:
     // serialize/deserialize to/from stream.
 public:
     virtual int total_size();
-    virtual int read(SrsBuffer* stream);
-    virtual int write(SrsBuffer* stream);
+    virtual srs_error_t read(SrsBuffer* stream);
+    virtual srs_error_t write(SrsBuffer* stream);
     virtual SrsAmf0Any* copy();
     /**
      * convert amf0 to json.
@@ -582,15 +582,15 @@ public:
  * @param ppvalue, the output amf0 any elem.
  *         NULL if error; otherwise, never NULL and user must free it.
  */
-extern int srs_amf0_read_any(SrsBuffer* stream, SrsAmf0Any** ppvalue);
+extern srs_error_t srs_amf0_read_any(SrsBuffer* stream, SrsAmf0Any** ppvalue);
 
 /**
  * read amf0 string from stream.
  * 2.4 String Type
  * string-type = string-marker UTF-8
  */
-extern int srs_amf0_read_string(SrsBuffer* stream, std::string& value);
-extern int srs_amf0_write_string(SrsBuffer* stream, std::string value);
+extern srs_error_t srs_amf0_read_string(SrsBuffer* stream, std::string& value);
+extern srs_error_t srs_amf0_write_string(SrsBuffer* stream, std::string value);
 
 /**
  * read amf0 boolean from stream.
@@ -598,32 +598,32 @@ extern int srs_amf0_write_string(SrsBuffer* stream, std::string value);
  * boolean-type = boolean-marker U8
  *         0 is false, <> 0 is true
  */
-extern int srs_amf0_read_boolean(SrsBuffer* stream, bool& value);
-extern int srs_amf0_write_boolean(SrsBuffer* stream, bool value);
+extern srs_error_t srs_amf0_read_boolean(SrsBuffer* stream, bool& value);
+extern srs_error_t srs_amf0_write_boolean(SrsBuffer* stream, bool value);
 
 /**
  * read amf0 number from stream.
  * 2.2 Number Type
  * number-type = number-marker DOUBLE
  */
-extern int srs_amf0_read_number(SrsBuffer* stream, double& value);
-extern int srs_amf0_write_number(SrsBuffer* stream, double value);
+extern srs_error_t srs_amf0_read_number(SrsBuffer* stream, double& value);
+extern srs_error_t srs_amf0_write_number(SrsBuffer* stream, double value);
 
 /**
  * read amf0 null from stream.
  * 2.7 null Type
  * null-type = null-marker
  */
-extern int srs_amf0_read_null(SrsBuffer* stream);
-extern int srs_amf0_write_null(SrsBuffer* stream);
+extern srs_error_t srs_amf0_read_null(SrsBuffer* stream);
+extern srs_error_t srs_amf0_write_null(SrsBuffer* stream);
 
 /**
  * read amf0 undefined from stream.
  * 2.8 undefined Type
  * undefined-type = undefined-marker
  */
-extern int srs_amf0_read_undefined(SrsBuffer* stream);
-extern int srs_amf0_write_undefined(SrsBuffer* stream);
+extern srs_error_t srs_amf0_read_undefined(SrsBuffer* stream);
+extern srs_error_t srs_amf0_write_undefined(SrsBuffer* stream);
 
 // internal objects, user should never use it.
 namespace _srs_internal
@@ -650,8 +650,8 @@ namespace _srs_internal
         virtual ~SrsAmf0String();
     public:
         virtual int total_size();
-        virtual int read(SrsBuffer* stream);
-        virtual int write(SrsBuffer* stream);
+        virtual srs_error_t read(SrsBuffer* stream);
+        virtual srs_error_t write(SrsBuffer* stream);
         virtual SrsAmf0Any* copy();
     };
     
@@ -677,8 +677,8 @@ namespace _srs_internal
         virtual ~SrsAmf0Boolean();
     public:
         virtual int total_size();
-        virtual int read(SrsBuffer* stream);
-        virtual int write(SrsBuffer* stream);
+        virtual srs_error_t read(SrsBuffer* stream);
+        virtual srs_error_t write(SrsBuffer* stream);
         virtual SrsAmf0Any* copy();
     };
     
@@ -703,8 +703,8 @@ namespace _srs_internal
         virtual ~SrsAmf0Number();
     public:
         virtual int total_size();
-        virtual int read(SrsBuffer* stream);
-        virtual int write(SrsBuffer* stream);
+        virtual srs_error_t read(SrsBuffer* stream);
+        virtual srs_error_t write(SrsBuffer* stream);
         virtual SrsAmf0Any* copy();
     };
     
@@ -731,8 +731,8 @@ namespace _srs_internal
         // serialize/deserialize to/from stream.
     public:
         virtual int total_size();
-        virtual int read(SrsBuffer* stream);
-        virtual int write(SrsBuffer* stream);
+        virtual srs_error_t read(SrsBuffer* stream);
+        virtual srs_error_t write(SrsBuffer* stream);
         virtual SrsAmf0Any* copy();
     public:
         /**
@@ -763,8 +763,8 @@ namespace _srs_internal
         virtual ~SrsAmf0Null();
     public:
         virtual int total_size();
-        virtual int read(SrsBuffer* stream);
-        virtual int write(SrsBuffer* stream);
+        virtual srs_error_t read(SrsBuffer* stream);
+        virtual srs_error_t write(SrsBuffer* stream);
         virtual SrsAmf0Any* copy();
     };
     
@@ -786,8 +786,8 @@ namespace _srs_internal
         virtual ~SrsAmf0Undefined();
     public:
         virtual int total_size();
-        virtual int read(SrsBuffer* stream);
-        virtual int write(SrsBuffer* stream);
+        virtual srs_error_t read(SrsBuffer* stream);
+        virtual srs_error_t write(SrsBuffer* stream);
         virtual SrsAmf0Any* copy();
     };
     
@@ -837,8 +837,8 @@ namespace _srs_internal
         virtual ~SrsAmf0ObjectEOF();
     public:
         virtual int total_size();
-        virtual int read(SrsBuffer* stream);
-        virtual int write(SrsBuffer* stream);
+        virtual srs_error_t read(SrsBuffer* stream);
+        virtual srs_error_t write(SrsBuffer* stream);
         virtual SrsAmf0Any* copy();
     };
     
@@ -850,13 +850,13 @@ namespace _srs_internal
      * UTF8-1 = %x00-7F
      * @remark only support UTF8-1 char.
      */
-    extern int srs_amf0_read_utf8(SrsBuffer* stream, std::string& value);
-    extern int srs_amf0_write_utf8(SrsBuffer* stream, std::string value);
+    extern srs_error_t srs_amf0_read_utf8(SrsBuffer* stream, std::string& value);
+    extern srs_error_t srs_amf0_write_utf8(SrsBuffer* stream, std::string value);
     
     extern bool srs_amf0_is_object_eof(SrsBuffer* stream);
-    extern int srs_amf0_write_object_eof(SrsBuffer* stream, SrsAmf0ObjectEOF* value);
+    extern srs_error_t srs_amf0_write_object_eof(SrsBuffer* stream, SrsAmf0ObjectEOF* value);
     
-    extern int srs_amf0_write_any(SrsBuffer* stream, SrsAmf0Any* value);
+    extern srs_error_t srs_amf0_write_any(SrsBuffer* stream, SrsAmf0Any* value);
 };
 
 #endif
diff --git a/trunk/src/protocol/srs_protocol_io.hpp b/trunk/src/protocol/srs_protocol_io.hpp
index 7a0145602..717cf5cc4 100644
--- a/trunk/src/protocol/srs_protocol_io.hpp
+++ b/trunk/src/protocol/srs_protocol_io.hpp
@@ -103,7 +103,7 @@ public:
      * read specified size bytes of data
      * @param nread, the actually read size, NULL to ignore.
      */
-    virtual int read_fully(void* buf, size_t size, ssize_t* nread) = 0;
+    virtual srs_error_t read_fully(void* buf, size_t size, ssize_t* nread) = 0;
 };
 
 /**
diff --git a/trunk/src/protocol/srs_protocol_stream.cpp b/trunk/src/protocol/srs_protocol_stream.cpp
index 32de59434..ab0caf3a7 100755
--- a/trunk/src/protocol/srs_protocol_stream.cpp
+++ b/trunk/src/protocol/srs_protocol_stream.cpp
@@ -131,13 +131,13 @@ void SrsFastStream::skip(int size)
     p += size;
 }
 
-int SrsFastStream::grow(ISrsReader* reader, int required_size)
+srs_error_t SrsFastStream::grow(ISrsReader* reader, int required_size)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // already got required size of bytes.
     if (end - p >= required_size) {
-        return ret;
+        return err;
     }
     
     // must be positive.
@@ -153,13 +153,10 @@ int SrsFastStream::grow(ISrsReader* reader, int required_size)
     
     // resize the space when no left space.
     if (nb_free_space < required_size - nb_exists_bytes) {
-        srs_verbose("move fast buffer %d bytes", nb_exists_bytes);
-        
         // reset or move to get more space.
         if (!nb_exists_bytes) {
             // reset when buffer is empty.
             p = end = buffer;
-            srs_verbose("all consumed, reset fast buffer");
         } else if (nb_exists_bytes < nb_buffer && p > buffer) {
             // move the left bytes to start of buffer.
             // @remark Only move memory when space is enough, or failed at next check.
@@ -172,18 +169,15 @@ int SrsFastStream::grow(ISrsReader* reader, int required_size)
         // check whether enough free space in buffer.
         nb_free_space = (int)(buffer + nb_buffer - end);
         if (nb_free_space < required_size - nb_exists_bytes) {
-            ret = ERROR_READER_BUFFER_OVERFLOW;
-            srs_error("buffer overflow, required=%d, max=%d, left=%d, ret=%d",
-                      required_size, nb_buffer, nb_free_space, ret);
-            return ret;
+            return srs_error_new(ERROR_READER_BUFFER_OVERFLOW, "overflow, required=%d, max=%d, left=%d", required_size, nb_buffer, nb_free_space);
         }
     }
     
     // buffer is ok, read required size of bytes.
     while (end - p < required_size) {
         ssize_t nread;
-        if ((ret = reader->read(end, nb_free_space, &nread)) != ERROR_SUCCESS) {
-            return ret;
+        if ((err = reader->read(end, nb_free_space, &nread)) != srs_success) {
+            return srs_error_wrap(err, "read bytes");
         }
         
 #ifdef SRS_PERF_MERGED_READ
@@ -204,7 +198,7 @@ int SrsFastStream::grow(ISrsReader* reader, int required_size)
         nb_free_space -= nread;
     }
     
-    return ret;
+    return err;
 }
 
 #ifdef SRS_PERF_MERGED_READ
diff --git a/trunk/src/protocol/srs_protocol_stream.hpp b/trunk/src/protocol/srs_protocol_stream.hpp
index 561ad2a18..f245a67c7 100644
--- a/trunk/src/protocol/srs_protocol_stream.hpp
+++ b/trunk/src/protocol/srs_protocol_stream.hpp
@@ -134,7 +134,7 @@ public:
      * @return an int error code, error if required_size negative.
      * @remark, we actually maybe read more than required_size, maybe 4k for example.
      */
-    virtual int grow(ISrsReader* reader, int required_size);
+    virtual srs_error_t grow(ISrsReader* reader, int required_size);
 public:
 #ifdef SRS_PERF_MERGED_READ
     /**
diff --git a/trunk/src/protocol/srs_protocol_utility.cpp b/trunk/src/protocol/srs_protocol_utility.cpp
index 9fa34375b..f3bbc30f8 100644
--- a/trunk/src/protocol/srs_protocol_utility.cpp
+++ b/trunk/src/protocol/srs_protocol_utility.cpp
@@ -309,9 +309,9 @@ string srs_generate_rtmp_url(string server, int port, string vhost, string app,
     return ss.str();
 }
 
-int srs_write_large_iovs(ISrsProtocolReaderWriter* skt, iovec* iovs, int size, ssize_t* pnwrite)
+srs_error_t srs_write_large_iovs(ISrsProtocolReaderWriter* skt, iovec* iovs, int size, ssize_t* pnwrite)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // the limits of writev iovs.
     // for srs-librtmp, @see https://github.com/ossrs/srs/issues/213
@@ -324,29 +324,23 @@ int srs_write_large_iovs(ISrsProtocolReaderWriter* skt, iovec* iovs, int size, s
     
     // send in a time.
     if (size < limits) {
-        if ((ret = skt->writev(iovs, size, pnwrite)) != ERROR_SUCCESS) {
-            if (!srs_is_client_gracefully_close(ret)) {
-                srs_error("send with writev failed. ret=%d", ret);
-            }
-            return ret;
+        if ((err = skt->writev(iovs, size, pnwrite)) != srs_success) {
+            return srs_error_wrap(err, "writev");
         }
-        return ret;
+        return err;
     }
     
     // send in multiple times.
     int cur_iov = 0;
     while (cur_iov < size) {
         int cur_count = srs_min(limits, size - cur_iov);
-        if ((ret = skt->writev(iovs + cur_iov, cur_count, pnwrite)) != ERROR_SUCCESS) {
-            if (!srs_is_client_gracefully_close(ret)) {
-                srs_error("send with writev failed. ret=%d", ret);
-            }
-            return ret;
+        if ((err = skt->writev(iovs + cur_iov, cur_count, pnwrite)) != srs_success) {
+            return srs_error_wrap(err, "writev");
         }
         cur_iov += cur_count;
     }
     
-    return ret;
+    return err;
 }
 
 string srs_join_vector_string(vector<string>& vs, string separator)
diff --git a/trunk/src/protocol/srs_protocol_utility.hpp b/trunk/src/protocol/srs_protocol_utility.hpp
index 6c99a8359..1d643d2a7 100644
--- a/trunk/src/protocol/srs_protocol_utility.hpp
+++ b/trunk/src/protocol/srs_protocol_utility.hpp
@@ -111,7 +111,7 @@ extern void srs_parse_rtmp_url(std::string url, std::string& tcUrl, std::string&
 extern std::string srs_generate_rtmp_url(std::string server, int port, std::string vhost, std::string app, std::string stream);
 
 // write large numbers of iovs.
-extern int srs_write_large_iovs(ISrsProtocolReaderWriter* skt, iovec* iovs, int size, ssize_t* pnwrite = NULL);
+extern srs_error_t srs_write_large_iovs(ISrsProtocolReaderWriter* skt, iovec* iovs, int size, ssize_t* pnwrite = NULL);
 
 // join string in vector with indicated separator
 extern std::string srs_join_vector_string(std::vector<std::string>& vs, std::string separator);
diff --git a/trunk/src/protocol/srs_rtmp_handshake.cpp b/trunk/src/protocol/srs_rtmp_handshake.cpp
index 7984f7348..432f35691 100644
--- a/trunk/src/protocol/srs_rtmp_handshake.cpp
+++ b/trunk/src/protocol/srs_rtmp_handshake.cpp
@@ -137,30 +137,28 @@ namespace _srs_internal
         0x93, 0xB8, 0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
     }; // 62
     
-    int do_openssl_HMACsha256(HMAC_CTX* ctx, const void* data, int data_size, void* digest, unsigned int* digest_size)
+    srs_error_t do_openssl_HMACsha256(HMAC_CTX* ctx, const void* data, int data_size, void* digest, unsigned int* digest_size)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         if (HMAC_Update(ctx, (unsigned char *) data, data_size) < 0) {
-            ret = ERROR_OpenSslSha256Update;
-            return ret;
+            return srs_error_new(ERROR_OpenSslSha256Update, "hmac update");
         }
         
         if (HMAC_Final(ctx, (unsigned char *) digest, digest_size) < 0) {
-            ret = ERROR_OpenSslSha256Final;
-            return ret;
+            return srs_error_new(ERROR_OpenSslSha256Final, "hmac final");
         }
         
-        return ret;
+        return err;
     }
     /**
      * sha256 digest algorithm.
      * @param key the sha256 key, NULL to use EVP_Digest, for instance,
      *       hashlib.sha256(data).digest().
      */
-    int openssl_HMACsha256(const void* key, int key_size, const void* data, int data_size, void* digest)
+    srs_error_t openssl_HMACsha256(const void* key, int key_size, const void* data, int data_size, void* digest)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         unsigned int digest_size = 0;
         
@@ -171,40 +169,35 @@ namespace _srs_internal
             // use data to digest.
             // @see ./crypto/sha/sha256t.c
             // @see ./crypto/evp/digest.c
-            if (EVP_Digest(data, data_size, temp_digest, &digest_size, EVP_sha256(), NULL) < 0)
-            {
-                ret = ERROR_OpenSslSha256EvpDigest;
-                return ret;
+            if (EVP_Digest(data, data_size, temp_digest, &digest_size, EVP_sha256(), NULL) < 0) {
+                return srs_error_new(ERROR_OpenSslSha256EvpDigest, "evp digest");
             }
         } else {
             // use key-data to digest.
             HMAC_CTX *ctx = HMAC_CTX_new();
             if (ctx == NULL) {
-                ret = ERROR_OpenSslCreateHMAC;
-                return ret;
+                return srs_error_new(ERROR_OpenSslCreateHMAC, "hmac new");
             }
             // @remark, if no key, use EVP_Digest to digest,
             // for instance, in python, hashlib.sha256(data).digest().
             if (HMAC_Init_ex(ctx, temp_key, key_size, EVP_sha256(), NULL) < 0) {
-                ret = ERROR_OpenSslSha256Init;
                 HMAC_CTX_free(ctx);
-                return ret;
+                return srs_error_new(ERROR_OpenSslSha256Init, "hmac init");
             }
             
-            ret = do_openssl_HMACsha256(ctx, data, data_size, temp_digest, &digest_size);
+            err = do_openssl_HMACsha256(ctx, data, data_size, temp_digest, &digest_size);
             HMAC_CTX_free(ctx);
             
-            if (ret != ERROR_SUCCESS) {
-                return ret;
+            if (err != srs_success) {
+                return srs_error_wrap(err, "hmac sha256");
             }
         }
         
         if (digest_size != 32) {
-            ret = ERROR_OpenSslSha256DigestSize;
-            return ret;
+            return srs_error_new(ERROR_OpenSslSha256DigestSize, "digest size %d", digest_size);
         }
         
-        return ret;
+        return err;
     }
     
 #define RFC2409_PRIME_1024 \
@@ -233,13 +226,13 @@ namespace _srs_internal
         }
     }
     
-    int SrsDH::initialize(bool ensure_128bytes_public_key)
+    srs_error_t SrsDH::initialize(bool ensure_128bytes_public_key)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         for (;;) {
-            if ((ret = do_initialize()) != ERROR_SUCCESS) {
-                return ret;
+            if ((err = do_initialize()) != srs_success) {
+                return srs_error_wrap(err, "init");
             }
             
             if (ensure_128bytes_public_key) {
@@ -255,12 +248,12 @@ namespace _srs_internal
             break;
         }
         
-        return ret;
+        return err;
     }
     
-    int SrsDH::copy_public_key(char* pkey, int32_t& pkey_size)
+    srs_error_t SrsDH::copy_public_key(char* pkey, int32_t& pkey_size)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         // copy public key to bytes.
         // sometimes, the key_size is 127, seems ok.
@@ -280,17 +273,16 @@ namespace _srs_internal
         srs_assert(key_size <= pkey_size);
         pkey_size = key_size;
         
-        return ret;
+        return err;
     }
     
-    int SrsDH::copy_shared_key(const char* ppkey, int32_t ppkey_size, char* skey, int32_t& skey_size)
+    srs_error_t SrsDH::copy_shared_key(const char* ppkey, int32_t ppkey_size, char* skey, int32_t& skey_size)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         BIGNUM* ppk = NULL;
         if ((ppk = BN_bin2bn((const unsigned char*)ppkey, ppkey_size, 0)) == NULL) {
-            ret = ERROR_OpenSslGetPeerPublicKey;
-            return ret;
+            return srs_error_new(ERROR_OpenSslGetPeerPublicKey, "bin2bn");
         }
         
         // if failed, donot return, do cleanup, @see ./test/dhtest.c:168
@@ -304,7 +296,7 @@ namespace _srs_internal
         }
         
         if (key_size < 0 || key_size > skey_size) {
-            ret = ERROR_OpenSslComputeSharedKey;
+            err = srs_error_new(ERROR_OpenSslComputeSharedKey, "key size %d", key_size);
         } else {
             skey_size = key_size;
         }
@@ -313,12 +305,12 @@ namespace _srs_internal
             BN_free(ppk);
         }
         
-        return ret;
+        return err;
     }
     
-    int SrsDH::do_initialize()
+    srs_error_t SrsDH::do_initialize()
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         int32_t bits_count = 1024;
         
@@ -326,32 +318,27 @@ namespace _srs_internal
         
         //1. Create the DH
         if ((pdh = DH_new()) == NULL) {
-            ret = ERROR_OpenSslCreateDH;
-            return ret;
+            return srs_error_new(ERROR_OpenSslCreateDH, "dh new");
         }
         
         //2. Create his internal p and g
         BIGNUM *p, *g;
         if ((p = BN_new()) == NULL) {
-            ret = ERROR_OpenSslCreateP;
-            return ret;
+            return srs_error_new(ERROR_OpenSslCreateP, "dh new");
         }
         if ((g = BN_new()) == NULL) {
-            ret = ERROR_OpenSslCreateG;
             BN_free(p);
-            return ret;
+            return srs_error_new(ERROR_OpenSslCreateG, "bn new");
         }
         DH_set0_pqg(pdh, p, NULL, g);
         
         //3. initialize p and g, @see ./test/ectest.c:260
         if (!BN_hex2bn(&p, RFC2409_PRIME_1024)) {
-            ret = ERROR_OpenSslParseP1024;
-            return ret;
+            return srs_error_new(ERROR_OpenSslParseP1024, "hex2bn");
         }
         // @see ./test/bntest.c:1764
         if (!BN_set_word(g, 2)) {
-            ret = ERROR_OpenSslSetG;
-            return ret;
+            return srs_error_new(ERROR_OpenSslSetG, "set word");
         }
         
         // 4. Set the key length
@@ -360,11 +347,10 @@ namespace _srs_internal
         // 5. Generate private and public key
         // @see ./test/dhtest.c:152
         if (!DH_generate_key(pdh)) {
-            ret = ERROR_OpenSslGenerateDHKeys;
-            return ret;
+            return srs_error_new(ERROR_OpenSslGenerateDHKeys, "dh generate key");
         }
         
-        return ret;
+        return err;
     }
     
     key_block::key_block()
@@ -399,9 +385,9 @@ namespace _srs_internal
         srs_freepa(random1);
     }
     
-    int key_block::parse(SrsBuffer* stream)
+    srs_error_t key_block::parse(SrsBuffer* stream)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         // the key must be 764 bytes.
         srs_assert(stream->require(764));
@@ -432,7 +418,7 @@ namespace _srs_internal
             stream->read_bytes(random1, random1_size);
         }
         
-        return ret;
+        return err;
     }
     
     int key_block::calc_valid_offset()
@@ -481,9 +467,9 @@ namespace _srs_internal
         srs_freepa(random1);
     }
     
-    int digest_block::parse(SrsBuffer* stream)
+    srs_error_t digest_block::parse(SrsBuffer* stream)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         // the digest must be 764 bytes.
         srs_assert(stream->require(764));
@@ -509,7 +495,7 @@ namespace _srs_internal
             stream->read_bytes(random1, random1_size);
         }
         
-        return ret;
+        return err;
     }
     
     int digest_block::calc_valid_offset()
@@ -544,22 +530,21 @@ namespace _srs_internal
         return key.key;
     }
     
-    int c1s1_strategy::dump(c1s1* owner, char* _c1s1, int size)
+    srs_error_t c1s1_strategy::dump(c1s1* owner, char* _c1s1, int size)
     {
         srs_assert(size == 1536);
         return copy_to(owner, _c1s1, size, true);
     }
     
-    int c1s1_strategy::c1_create(c1s1* owner)
+    srs_error_t c1s1_strategy::c1_create(c1s1* owner)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         // generate digest
         char* c1_digest = NULL;
         
-        if ((ret = calc_c1_digest(owner, c1_digest)) != ERROR_SUCCESS) {
-            srs_error("sign c1 error, failed to calc digest. ret=%d", ret);
-            return ret;
+        if ((err = calc_c1_digest(owner, c1_digest)) != srs_success) {
+            return srs_error_wrap(err, "sign c1");
         }
         
         srs_assert(c1_digest != NULL);
@@ -567,18 +552,17 @@ namespace _srs_internal
         
         memcpy(digest.digest, c1_digest, 32);
         
-        return ret;
+        return err;
     }
     
-    int c1s1_strategy::c1_validate_digest(c1s1* owner, bool& is_valid)
+    srs_error_t c1s1_strategy::c1_validate_digest(c1s1* owner, bool& is_valid)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         char* c1_digest = NULL;
         
-        if ((ret = calc_c1_digest(owner, c1_digest)) != ERROR_SUCCESS) {
-            srs_error("validate c1 error, failed to calc digest. ret=%d", ret);
-            return ret;
+        if ((err = calc_c1_digest(owner, c1_digest)) != srs_success) {
+            return srs_error_wrap(err, "validate c1");
         }
         
         srs_assert(c1_digest != NULL);
@@ -586,59 +570,53 @@ namespace _srs_internal
         
         is_valid = srs_bytes_equals(digest.digest, c1_digest, 32);
         
-        return ret;
+        return err;
     }
     
-    int c1s1_strategy::s1_create(c1s1* owner, c1s1* c1)
+    srs_error_t c1s1_strategy::s1_create(c1s1* owner, c1s1* c1)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         SrsDH dh;
         
         // ensure generate 128bytes public key.
-        if ((ret = dh.initialize(true)) != ERROR_SUCCESS) {
-            return ret;
+        if ((err = dh.initialize(true)) != srs_success) {
+            return srs_error_wrap(err, "dh init");
         }
         
         // directly generate the public key.
         // @see: https://github.com/ossrs/srs/issues/148
         int pkey_size = 128;
-        if ((ret = dh.copy_shared_key(c1->get_key(), 128, key.key, pkey_size)) != ERROR_SUCCESS) {
-            srs_error("calc s1 key failed. ret=%d", ret);
-            return ret;
+        if ((err = dh.copy_shared_key(c1->get_key(), 128, key.key, pkey_size)) != srs_success) {
+            return srs_error_wrap(err, "copy shared key");
         }
         
         // although the public key is always 128bytes, but the share key maybe not.
         // we just ignore the actual key size, but if need to use the key, must use the actual size.
         // TODO: FIXME: use the actual key size.
         //srs_assert(pkey_size == 128);
-        srs_verbose("calc s1 key success.");
         
         char* s1_digest = NULL;
-        if ((ret = calc_s1_digest(owner, s1_digest))  != ERROR_SUCCESS) {
-            srs_error("calc s1 digest failed. ret=%d", ret);
-            return ret;
+        if ((err = calc_s1_digest(owner, s1_digest))  != srs_success) {
+            return srs_error_wrap(err, "calc s1 digest");
         }
-        srs_verbose("calc s1 digest success.");
         
         srs_assert(s1_digest != NULL);
         SrsAutoFreeA(char, s1_digest);
         
         memcpy(digest.digest, s1_digest, 32);
-        srs_verbose("copy s1 key success.");
         
-        return ret;
+        return err;
     }
     
-    int c1s1_strategy::s1_validate_digest(c1s1* owner, bool& is_valid)
+    srs_error_t c1s1_strategy::s1_validate_digest(c1s1* owner, bool& is_valid)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         char* s1_digest = NULL;
         
-        if ((ret = calc_s1_digest(owner, s1_digest)) != ERROR_SUCCESS) {
-            srs_error("validate s1 error, failed to calc digest. ret=%d", ret);
-            return ret;
+        if ((err = calc_s1_digest(owner, s1_digest)) != srs_success) {
+            return srs_error_wrap(err, "validate s1");
         }
         
         srs_assert(s1_digest != NULL);
@@ -646,12 +624,12 @@ namespace _srs_internal
         
         is_valid = srs_bytes_equals(digest.digest, s1_digest, 32);
         
-        return ret;
+        return err;
     }
     
-    int c1s1_strategy::calc_c1_digest(c1s1* owner, char*& c1_digest)
+    srs_error_t c1s1_strategy::calc_c1_digest(c1s1* owner, char*& c1_digest)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         /**
          * c1s1 is splited by digest:
@@ -662,24 +640,22 @@ namespace _srs_internal
          */
         char* c1s1_joined_bytes = new char[1536 -32];
         SrsAutoFreeA(char, c1s1_joined_bytes);
-        if ((ret = copy_to(owner, c1s1_joined_bytes, 1536 - 32, false)) != ERROR_SUCCESS) {
-            return ret;
+        if ((err = copy_to(owner, c1s1_joined_bytes, 1536 - 32, false)) != srs_success) {
+            return srs_error_wrap(err, "copy bytes");
         }
         
         c1_digest = new char[SRS_OpensslHashSize];
-        if ((ret = openssl_HMACsha256(SrsGenuineFPKey, 30, c1s1_joined_bytes, 1536 - 32, c1_digest)) != ERROR_SUCCESS) {
+        if ((err = openssl_HMACsha256(SrsGenuineFPKey, 30, c1s1_joined_bytes, 1536 - 32, c1_digest)) != srs_success) {
             srs_freepa(c1_digest);
-            srs_error("calc digest for c1 failed. ret=%d", ret);
-            return ret;
+            return srs_error_wrap(err, "calc c1 digest");
         }
-        srs_verbose("digest calculated for c1");
         
-        return ret;
+        return err;
     }
     
-    int c1s1_strategy::calc_s1_digest(c1s1* owner, char*& s1_digest)
+    srs_error_t c1s1_strategy::calc_s1_digest(c1s1* owner, char*& s1_digest)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         /**
          * c1s1 is splited by digest:
@@ -690,19 +666,17 @@ namespace _srs_internal
          */
         char* c1s1_joined_bytes = new char[1536 -32];
         SrsAutoFreeA(char, c1s1_joined_bytes);
-        if ((ret = copy_to(owner, c1s1_joined_bytes, 1536 - 32, false)) != ERROR_SUCCESS) {
-            return ret;
+        if ((err = copy_to(owner, c1s1_joined_bytes, 1536 - 32, false)) != srs_success) {
+            return srs_error_wrap(err, "copy bytes");
         }
         
         s1_digest = new char[SRS_OpensslHashSize];
-        if ((ret = openssl_HMACsha256(SrsGenuineFMSKey, 36, c1s1_joined_bytes, 1536 - 32, s1_digest)) != ERROR_SUCCESS) {
+        if ((err = openssl_HMACsha256(SrsGenuineFMSKey, 36, c1s1_joined_bytes, 1536 - 32, s1_digest)) != srs_success) {
             srs_freepa(s1_digest);
-            srs_error("calc digest for s1 failed. ret=%d", ret);
-            return ret;
+            return srs_error_wrap(err, "calc s1 digest");
         }
-        srs_verbose("digest calculated for s1");
         
-        return ret;
+        return err;
     }
     
     void c1s1_strategy::copy_time_version(SrsBuffer* stream, c1s1* owner)
@@ -780,40 +754,34 @@ namespace _srs_internal
         return srs_schema0;
     }
     
-    int c1s1_strategy_schema0::parse(char* _c1s1, int size)
+    srs_error_t c1s1_strategy_schema0::parse(char* _c1s1, int size)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         srs_assert(size == 1536);
         
-        SrsBuffer stream;
-        
-        if ((ret = stream.initialize(_c1s1 + 8, 764)) != ERROR_SUCCESS) {
-            return ret;
+        if (true) {
+            SrsBuffer stream(_c1s1 + 8, 764);
+            
+            if ((err = key.parse(&stream)) != srs_success) {
+                return srs_error_wrap(err, "parse the c1 key");
+            }
         }
         
-        if ((ret = key.parse(&stream)) != ERROR_SUCCESS) {
-            srs_error("parse the c1 key failed. ret=%d", ret);
-            return ret;
+        if (true) {
+            SrsBuffer stream(_c1s1 + 8 + 764, 764);
+        
+            if ((err = digest.parse(&stream)) != srs_success) {
+                return srs_error_wrap(err, "parse the c1 digest");
+            }
         }
         
-        if ((ret = stream.initialize(_c1s1 + 8 + 764, 764)) != ERROR_SUCCESS) {
-            return ret;
-        }
-        
-        if ((ret = digest.parse(&stream)) != ERROR_SUCCESS) {
-            srs_error("parse the c1 digest failed. ret=%d", ret);
-            return ret;
-        }
-        
-        srs_verbose("parse c1 key-digest success");
-        
-        return ret;
+        return err;
     }
     
-    int c1s1_strategy_schema0::copy_to(c1s1* owner, char* bytes, int size, bool with_digest)
+    srs_error_t c1s1_strategy_schema0::copy_to(c1s1* owner, char* bytes, int size, bool with_digest)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         if (with_digest) {
             srs_assert(size == 1536);
@@ -821,11 +789,7 @@ namespace _srs_internal
             srs_assert(size == 1504);
         }
         
-        SrsBuffer stream;
-        
-        if ((ret = stream.initialize(bytes, size)) != ERROR_SUCCESS) {
-            return ret;
-        }
+        SrsBuffer stream(bytes, size);
         
         copy_time_version(&stream, owner);
         copy_key(&stream);
@@ -833,7 +797,7 @@ namespace _srs_internal
         
         srs_assert(stream.empty());
         
-        return ret;
+        return err;
     }
     
     c1s1_strategy_schema1::c1s1_strategy_schema1()
@@ -849,40 +813,34 @@ namespace _srs_internal
         return srs_schema1;
     }
     
-    int c1s1_strategy_schema1::parse(char* _c1s1, int size)
+    srs_error_t c1s1_strategy_schema1::parse(char* _c1s1, int size)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         srs_assert(size == 1536);
         
-        SrsBuffer stream;
-        
-        if ((ret = stream.initialize(_c1s1 + 8, 764)) != ERROR_SUCCESS) {
-            return ret;
+        if (true) {
+            SrsBuffer stream(_c1s1 + 8, 764);
+            
+            if ((err = digest.parse(&stream)) != srs_success) {
+                return srs_error_wrap(err, "parse c1 digest");
+            }
         }
         
-        if ((ret = digest.parse(&stream)) != ERROR_SUCCESS) {
-            srs_error("parse the c1 digest failed. ret=%d", ret);
-            return ret;
+        if (true) {
+            SrsBuffer stream(_c1s1 + 8 + 764, 764);
+            
+            if ((err = key.parse(&stream)) != srs_success) {
+                return srs_error_wrap(err, "parse c1 key");
+            }
         }
         
-        if ((ret = stream.initialize(_c1s1 + 8 + 764, 764)) != ERROR_SUCCESS) {
-            return ret;
-        }
-        
-        if ((ret = key.parse(&stream)) != ERROR_SUCCESS) {
-            srs_error("parse the c1 key failed. ret=%d", ret);
-            return ret;
-        }
-        
-        srs_verbose("parse c1 digest-key success");
-        
-        return ret;
+        return err;
     }
     
-    int c1s1_strategy_schema1::copy_to(c1s1* owner, char* bytes, int size, bool with_digest)
+    srs_error_t c1s1_strategy_schema1::copy_to(c1s1* owner, char* bytes, int size, bool with_digest)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         if (with_digest) {
             srs_assert(size == 1536);
@@ -890,11 +848,7 @@ namespace _srs_internal
             srs_assert(size == 1504);
         }
         
-        SrsBuffer stream;
-        
-        if ((ret = stream.initialize(bytes, size)) != ERROR_SUCCESS) {
-            return ret;
-        }
+        SrsBuffer stream(bytes, size);
         
         copy_time_version(&stream, owner);
         copy_digest(&stream, with_digest);
@@ -902,7 +856,7 @@ namespace _srs_internal
         
         srs_assert(stream.empty());
         
-        return ret;
+        return err;
     }
     
     c1s1::c1s1()
@@ -932,30 +886,24 @@ namespace _srs_internal
         return payload->get_key();
     }
     
-    int c1s1::dump(char* _c1s1, int size)
+    srs_error_t c1s1::dump(char* _c1s1, int size)
     {
         srs_assert(size == 1536);
         srs_assert(payload != NULL);
         return payload->dump(this, _c1s1, size);
     }
     
-    int c1s1::parse(char* _c1s1, int size, srs_schema_type schema)
+    srs_error_t c1s1::parse(char* _c1s1, int size, srs_schema_type schema)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         srs_assert(size == 1536);
         
         if (schema != srs_schema0 && schema != srs_schema1) {
-            ret = ERROR_RTMP_CH_SCHEMA;
-            srs_error("parse c1 failed. invalid schema=%d, ret=%d", schema, ret);
-            return ret;
+            return srs_error_new(ERROR_RTMP_CH_SCHEMA, "parse c1 failed. invalid schema=%d", schema);
         }
         
-        SrsBuffer stream;
-        
-        if ((ret = stream.initialize(_c1s1, size)) != ERROR_SUCCESS) {
-            return ret;
-        }
+        SrsBuffer stream(_c1s1, size);
         
         time = stream.read_4bytes();
         version = stream.read_4bytes(); // client c1 version
@@ -970,14 +918,12 @@ namespace _srs_internal
         return payload->parse(_c1s1, size);
     }
     
-    int c1s1::c1_create(srs_schema_type schema)
+    srs_error_t c1s1::c1_create(srs_schema_type schema)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         if (schema != srs_schema0 && schema != srs_schema1) {
-            ret = ERROR_RTMP_CH_SCHEMA;
-            srs_error("create c1 failed. invalid schema=%d, ret=%d", schema, ret);
-            return ret;
+            return srs_error_new(ERROR_RTMP_CH_SCHEMA, "create c1 failed. invalid schema=%d", schema);
         }
         
         // client c1 time and version
@@ -995,21 +941,19 @@ namespace _srs_internal
         return payload->c1_create(this);
     }
     
-    int c1s1::c1_validate_digest(bool& is_valid)
+    srs_error_t c1s1::c1_validate_digest(bool& is_valid)
     {
         is_valid = false;
         srs_assert(payload);
         return payload->c1_validate_digest(this, is_valid);
     }
     
-    int c1s1::s1_create(c1s1* c1)
+    srs_error_t c1s1::s1_create(c1s1* c1)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         if (c1->schema() != srs_schema0 && c1->schema() != srs_schema1) {
-            ret = ERROR_RTMP_CH_SCHEMA;
-            srs_error("create s1 failed. invalid schema=%d, ret=%d", c1->schema(), ret);
-            return ret;
+            return srs_error_new(ERROR_RTMP_CH_SCHEMA, "create s1 failed. invalid schema=%d", c1->schema());
         }
         
         time = ::time(NULL);
@@ -1025,7 +969,7 @@ namespace _srs_internal
         return payload->s1_create(this, c1);
     }
     
-    int c1s1::s1_validate_digest(bool& is_valid)
+    srs_error_t c1s1::s1_validate_digest(bool& is_valid)
     {
         is_valid = false;
         srs_assert(payload);
@@ -1047,118 +991,102 @@ namespace _srs_internal
     {
     }
     
-    int c2s2::dump(char* _c2s2, int size)
+    srs_error_t c2s2::dump(char* _c2s2, int size)
     {
         srs_assert(size == 1536);
         
         memcpy(_c2s2, random, 1504);
         memcpy(_c2s2 + 1504, digest, 32);
         
-        return ERROR_SUCCESS;
+        return srs_success;
     }
     
-    int c2s2::parse(char* _c2s2, int size)
+    srs_error_t c2s2::parse(char* _c2s2, int size)
     {
         srs_assert(size == 1536);
         
         memcpy(random, _c2s2, 1504);
         memcpy(digest, _c2s2 + 1504, 32);
         
-        return ERROR_SUCCESS;
+        return srs_success;
     }
     
-    int c2s2::c2_create(c1s1* s1)
+    srs_error_t c2s2::c2_create(c1s1* s1)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         char temp_key[SRS_OpensslHashSize];
-        if ((ret = openssl_HMACsha256(SrsGenuineFPKey, 62, s1->get_digest(), 32, temp_key)) != ERROR_SUCCESS) {
-            srs_error("create c2 temp key failed. ret=%d", ret);
-            return ret;
+        if ((err = openssl_HMACsha256(SrsGenuineFPKey, 62, s1->get_digest(), 32, temp_key)) != srs_success) {
+            return srs_error_wrap(err, "create c2 temp key");
         }
-        srs_verbose("generate c2 temp key success.");
         
         char _digest[SRS_OpensslHashSize];
-        if ((ret = openssl_HMACsha256(temp_key, 32, random, 1504, _digest)) != ERROR_SUCCESS) {
-            srs_error("create c2 digest failed. ret=%d", ret);
-            return ret;
+        if ((err = openssl_HMACsha256(temp_key, 32, random, 1504, _digest)) != srs_success) {
+            return srs_error_wrap(err, "create c2 digest");
         }
-        srs_verbose("generate c2 digest success.");
         
         memcpy(digest, _digest, 32);
         
-        return ret;
+        return err;
     }
     
-    int c2s2::c2_validate(c1s1* s1, bool& is_valid)
+    srs_error_t c2s2::c2_validate(c1s1* s1, bool& is_valid)
     {
         is_valid = false;
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         char temp_key[SRS_OpensslHashSize];
-        if ((ret = openssl_HMACsha256(SrsGenuineFPKey, 62, s1->get_digest(), 32, temp_key)) != ERROR_SUCCESS) {
-            srs_error("create c2 temp key failed. ret=%d", ret);
-            return ret;
+        if ((err = openssl_HMACsha256(SrsGenuineFPKey, 62, s1->get_digest(), 32, temp_key)) != srs_success) {
+            return srs_error_wrap(err, "create c2 temp key");
         }
-        srs_verbose("generate c2 temp key success.");
         
         char _digest[SRS_OpensslHashSize];
-        if ((ret = openssl_HMACsha256(temp_key, 32, random, 1504, _digest)) != ERROR_SUCCESS) {
-            srs_error("create c2 digest failed. ret=%d", ret);
-            return ret;
+        if ((err = openssl_HMACsha256(temp_key, 32, random, 1504, _digest)) != srs_success) {
+            return srs_error_wrap(err, "create c2 digest");
         }
-        srs_verbose("generate c2 digest success.");
         
         is_valid = srs_bytes_equals(digest, _digest, 32);
         
-        return ret;
+        return err;
     }
     
-    int c2s2::s2_create(c1s1* c1)
+    srs_error_t c2s2::s2_create(c1s1* c1)
     {
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         char temp_key[SRS_OpensslHashSize];
-        if ((ret = openssl_HMACsha256(SrsGenuineFMSKey, 68, c1->get_digest(), 32, temp_key)) != ERROR_SUCCESS) {
-            srs_error("create s2 temp key failed. ret=%d", ret);
-            return ret;
+        if ((err = openssl_HMACsha256(SrsGenuineFMSKey, 68, c1->get_digest(), 32, temp_key)) != srs_success) {
+            return srs_error_wrap(err, "create s2 temp key");
         }
-        srs_verbose("generate s2 temp key success.");
         
         char _digest[SRS_OpensslHashSize];
-        if ((ret = openssl_HMACsha256(temp_key, 32, random, 1504, _digest)) != ERROR_SUCCESS) {
-            srs_error("create s2 digest failed. ret=%d", ret);
-            return ret;
+        if ((err = openssl_HMACsha256(temp_key, 32, random, 1504, _digest)) != srs_success) {
+            return srs_error_wrap(err, "create s2 digest");
         }
-        srs_verbose("generate s2 digest success.");
         
         memcpy(digest, _digest, 32);
         
-        return ret;
+        return err;
     }
     
-    int c2s2::s2_validate(c1s1* c1, bool& is_valid)
+    srs_error_t c2s2::s2_validate(c1s1* c1, bool& is_valid)
     {
         is_valid = false;
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         char temp_key[SRS_OpensslHashSize];
-        if ((ret = openssl_HMACsha256(SrsGenuineFMSKey, 68, c1->get_digest(), 32, temp_key)) != ERROR_SUCCESS) {
-            srs_error("create s2 temp key failed. ret=%d", ret);
-            return ret;
+        if ((err = openssl_HMACsha256(SrsGenuineFMSKey, 68, c1->get_digest(), 32, temp_key)) != srs_success) {
+            return srs_error_wrap(err, "create s2 temp key");
         }
-        srs_verbose("generate s2 temp key success.");
         
         char _digest[SRS_OpensslHashSize];
-        if ((ret = openssl_HMACsha256(temp_key, 32, random, 1504, _digest)) != ERROR_SUCCESS) {
-            srs_error("create s2 digest failed. ret=%d", ret);
-            return ret;
+        if ((err = openssl_HMACsha256(temp_key, 32, random, 1504, _digest)) != srs_success) {
+            return srs_error_wrap(err, "create s2 digest");
         }
-        srs_verbose("generate s2 digest success.");
         
         is_valid = srs_bytes_equals(digest, _digest, 32);
         
-        return ret;
+        return err;
     }
 }
 
@@ -1172,88 +1100,77 @@ SrsSimpleHandshake::~SrsSimpleHandshake()
 {
 }
 
-int SrsSimpleHandshake::handshake_with_client(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io)
+srs_error_t SrsSimpleHandshake::handshake_with_client(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     ssize_t nsize;
     
-    if ((ret = hs_bytes->read_c0c1(io)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = hs_bytes->read_c0c1(io)) != srs_success) {
+        return srs_error_wrap(err, "read c0c1");
     }
     
     // plain text required.
     if (hs_bytes->c0c1[0] != 0x03) {
-        ret = ERROR_RTMP_PLAIN_REQUIRED;
-        srs_warn("only support rtmp plain text. ret=%d", ret);
-        return ret;
-    }
-    srs_verbose("check c0 success, required plain text.");
-    
-    if ((ret = hs_bytes->create_s0s1s2(hs_bytes->c0c1 + 1)) != ERROR_SUCCESS) {
-        return ret;
+        return srs_error_new(ERROR_RTMP_PLAIN_REQUIRED, "only support rtmp plain text, version=%X", (uint8_t)hs_bytes->c0c1[0]);
     }
     
-    if ((ret = io->write(hs_bytes->s0s1s2, 3073, &nsize)) != ERROR_SUCCESS) {
-        srs_warn("simple handshake send s0s1s2 failed. ret=%d", ret);
-        return ret;
+    if ((err = hs_bytes->create_s0s1s2(hs_bytes->c0c1 + 1)) != srs_success) {
+        return srs_error_wrap(err, "create s0s1s2");
     }
-    srs_verbose("simple handshake send s0s1s2 success.");
     
-    if ((ret = hs_bytes->read_c2(io)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = io->write(hs_bytes->s0s1s2, 3073, &nsize)) != srs_success) {
+        return srs_error_wrap(err, "write s0s1s2");
+    }
+    
+    if ((err = hs_bytes->read_c2(io)) != srs_success) {
+        return srs_error_wrap(err, "read c2");
     }
     
     srs_trace("simple handshake success.");
     
-    return ret;
+    return err;
 }
 
-int SrsSimpleHandshake::handshake_with_server(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io)
+srs_error_t SrsSimpleHandshake::handshake_with_server(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     ssize_t nsize;
     
     // simple handshake
-    if ((ret = hs_bytes->create_c0c1()) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = hs_bytes->create_c0c1()) != srs_success) {
+        return srs_error_wrap(err, "create c0c1");
     }
     
-    if ((ret = io->write(hs_bytes->c0c1, 1537, &nsize)) != ERROR_SUCCESS) {
-        srs_warn("write c0c1 failed. ret=%d", ret);
-        return ret;
+    if ((err = io->write(hs_bytes->c0c1, 1537, &nsize)) != srs_success) {
+        return srs_error_wrap(err, "write c0c1");
     }
-    srs_verbose("write c0c1 success.");
     
-    if ((ret = hs_bytes->read_s0s1s2(io)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = hs_bytes->read_s0s1s2(io)) != srs_success) {
+        return srs_error_wrap(err, "read s0s1s2");
     }
     
     // plain text required.
     if (hs_bytes->s0s1s2[0] != 0x03) {
-        ret = ERROR_RTMP_HANDSHAKE;
-        srs_warn("handshake failed, plain text required. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_HANDSHAKE, "handshake failed, plain text required, version=%X", (uint8_t)hs_bytes->s0s1s2[0]);
     }
     
-    if ((ret = hs_bytes->create_c2()) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = hs_bytes->create_c2()) != srs_success) {
+        return srs_error_wrap(err, "create c2");
     }
     
     // for simple handshake, copy s1 to c2.
     // @see https://github.com/ossrs/srs/issues/418
     memcpy(hs_bytes->c2, hs_bytes->s0s1s2 + 1, 1536);
     
-    if ((ret = io->write(hs_bytes->c2, 1536, &nsize)) != ERROR_SUCCESS) {
-        srs_warn("simple handshake write c2 failed. ret=%d", ret);
-        return ret;
+    if ((err = io->write(hs_bytes->c2, 1536, &nsize)) != srs_success) {
+        return srs_error_wrap(err, "write c2");
     }
-    srs_verbose("simple handshake write c2 success.");
     
     srs_trace("simple handshake success.");
     
-    return ret;
+    return err;
 }
 
 SrsComplexHandshake::SrsComplexHandshake()
@@ -1265,103 +1182,86 @@ SrsComplexHandshake::~SrsComplexHandshake()
 }
 
 #ifndef SRS_AUTO_SSL
-int SrsComplexHandshake::handshake_with_client(SrsHandshakeBytes* /*hs_bytes*/, ISrsProtocolReaderWriter* /*io*/)
+srs_error_t SrsComplexHandshake::handshake_with_client(SrsHandshakeBytes* /*hs_bytes*/, ISrsProtocolReaderWriter* /*io*/)
 {
     srs_trace("directly use simple handshake for ssl disabled.");
-    return ERROR_RTMP_TRY_SIMPLE_HS;
+    return srs_error_new(ERROR_RTMP_TRY_SIMPLE_HS, "try simple handshake");
 }
 #else
-int SrsComplexHandshake::handshake_with_client(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io)
+srs_error_t SrsComplexHandshake::handshake_with_client(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     ssize_t nsize;
     
-    if ((ret = hs_bytes->read_c0c1(io)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = hs_bytes->read_c0c1(io)) != srs_success) {
+        return srs_error_wrap(err, "read c0c1");
     }
     
     // decode c1
     c1s1 c1;
     // try schema0.
     // @remark, use schema0 to make flash player happy.
-    if ((ret = c1.parse(hs_bytes->c0c1 + 1, 1536, srs_schema0)) != ERROR_SUCCESS) {
-        srs_error("parse c1 schema%d error. ret=%d", srs_schema0, ret);
-        return ret;
+    if ((err = c1.parse(hs_bytes->c0c1 + 1, 1536, srs_schema0)) != srs_success) {
+        return srs_error_wrap(err, "parse c1, schema=%d", srs_schema0);
     }
     // try schema1
     bool is_valid = false;
-    if ((ret = c1.c1_validate_digest(is_valid)) != ERROR_SUCCESS || !is_valid) {
-        srs_info("schema0 failed, try schema1.");
-        if ((ret = c1.parse(hs_bytes->c0c1 + 1, 1536, srs_schema1)) != ERROR_SUCCESS) {
-            srs_error("parse c1 schema%d error. ret=%d", srs_schema1, ret);
-            return ret;
+    if ((err = c1.c1_validate_digest(is_valid)) != srs_success || !is_valid) {
+        srs_freep(err);
+        
+        if ((err = c1.parse(hs_bytes->c0c1 + 1, 1536, srs_schema1)) != srs_success) {
+            return srs_error_wrap(err, "parse c0c1, schame=%d", srs_schema1);
         }
         
-        if ((ret = c1.c1_validate_digest(is_valid)) != ERROR_SUCCESS || !is_valid) {
-            ret = ERROR_RTMP_TRY_SIMPLE_HS;
-            srs_info("all schema valid failed, try simple handshake. ret=%d", ret);
-            return ret;
+        if ((err = c1.c1_validate_digest(is_valid)) != srs_success || !is_valid) {
+            srs_freep(err);
+            return srs_error_new(ERROR_RTMP_TRY_SIMPLE_HS, "all schema valid failed, try simple handshake");
         }
-    } else {
-        srs_info("schema0 is ok.");
     }
-    srs_verbose("decode c1 success.");
     
     // encode s1
     c1s1 s1;
-    if ((ret = s1.s1_create(&c1)) != ERROR_SUCCESS) {
-        srs_error("create s1 from c1 failed. ret=%d", ret);
-        return ret;
+    if ((err = s1.s1_create(&c1)) != srs_success) {
+        return srs_error_wrap(err, "create s1 from c1");
     }
-    srs_verbose("create s1 from c1 success.");
     // verify s1
-    if ((ret = s1.s1_validate_digest(is_valid)) != ERROR_SUCCESS || !is_valid) {
-        ret = ERROR_RTMP_TRY_SIMPLE_HS;
-        srs_info("verify s1 failed, try simple handshake. ret=%d", ret);
-        return ret;
+    if ((err = s1.s1_validate_digest(is_valid)) != srs_success || !is_valid) {
+        srs_freep(err);
+        return srs_error_new(ERROR_RTMP_TRY_SIMPLE_HS, "verify s1 failed, try simple handshake");
     }
-    srs_verbose("verify s1 success.");
     
     c2s2 s2;
-    if ((ret = s2.s2_create(&c1)) != ERROR_SUCCESS) {
-        srs_error("create s2 from c1 failed. ret=%d", ret);
-        return ret;
+    if ((err = s2.s2_create(&c1)) != srs_success) {
+        return srs_error_wrap(err, "create s2 from c1");
     }
-    srs_verbose("create s2 from c1 success.");
     // verify s2
-    if ((ret = s2.s2_validate(&c1, is_valid)) != ERROR_SUCCESS || !is_valid) {
-        ret = ERROR_RTMP_TRY_SIMPLE_HS;
-        srs_info("verify s2 failed, try simple handshake. ret=%d", ret);
-        return ret;
+    if ((err = s2.s2_validate(&c1, is_valid)) != srs_success || !is_valid) {
+        return srs_error_new(ERROR_RTMP_TRY_SIMPLE_HS, "verify s2 failed, try simple handshake");
     }
-    srs_verbose("verify s2 success.");
     
     // sendout s0s1s2
-    if ((ret = hs_bytes->create_s0s1s2()) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = hs_bytes->create_s0s1s2()) != srs_success) {
+        return srs_error_wrap(err, "create s0s1s2");
     }
-    if ((ret = s1.dump(hs_bytes->s0s1s2 + 1, 1536)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = s1.dump(hs_bytes->s0s1s2 + 1, 1536)) != srs_success) {
+        return srs_error_wrap(err, "dump s1");
     }
-    if ((ret = s2.dump(hs_bytes->s0s1s2 + 1537, 1536)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = s2.dump(hs_bytes->s0s1s2 + 1537, 1536)) != srs_success) {
+        return srs_error_wrap(err, "dump s2");
     }
-    if ((ret = io->write(hs_bytes->s0s1s2, 3073, &nsize)) != ERROR_SUCCESS) {
-        srs_warn("complex handshake send s0s1s2 failed. ret=%d", ret);
-        return ret;
+    if ((err = io->write(hs_bytes->s0s1s2, 3073, &nsize)) != srs_success) {
+        return srs_error_wrap(err, "write s0s1s2");
     }
-    srs_verbose("complex handshake send s0s1s2 success.");
     
     // recv c2
-    if ((ret = hs_bytes->read_c2(io)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = hs_bytes->read_c2(io)) != srs_success) {
+        return srs_error_wrap(err, "read c2");
     }
     c2s2 c2;
-    if ((ret = c2.parse(hs_bytes->c2, 1536)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = c2.parse(hs_bytes->c2, 1536)) != srs_success) {
+        return srs_error_wrap(err, "parse c2");
     }
-    srs_verbose("complex handshake read c2 success.");
     
     // verify c2
     // never verify c2, for ffmpeg will failed.
@@ -1369,66 +1269,62 @@ int SrsComplexHandshake::handshake_with_client(SrsHandshakeBytes* hs_bytes, ISrs
     
     srs_trace("complex handshake success");
     
-    return ret;
+    return err;
 }
 #endif
 
 #ifndef SRS_AUTO_SSL
-int SrsComplexHandshake::handshake_with_server(SrsHandshakeBytes* /*hs_bytes*/, ISrsProtocolReaderWriter* /*io*/)
+srs_error_t SrsComplexHandshake::handshake_with_server(SrsHandshakeBytes* /*hs_bytes*/, ISrsProtocolReaderWriter* /*io*/)
 {
-    return ERROR_RTMP_TRY_SIMPLE_HS;
+    return srs_error_new(ERROR_RTMP_TRY_SIMPLE_HS, "try simple handshake");
 }
 #else
-int SrsComplexHandshake::handshake_with_server(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io)
+srs_error_t SrsComplexHandshake::handshake_with_server(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     ssize_t nsize;
     
     // complex handshake
-    if ((ret = hs_bytes->create_c0c1()) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = hs_bytes->create_c0c1()) != srs_success) {
+        return srs_error_wrap(err, "create c0c1");
     }
     
     // sign c1
     c1s1 c1;
     // @remark, FMS requires the schema1(digest-key), or connect failed.
-    if ((ret = c1.c1_create(srs_schema1)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = c1.c1_create(srs_schema1)) != srs_success) {
+        return srs_error_wrap(err, "create c1");
     }
-    if ((ret = c1.dump(hs_bytes->c0c1 + 1, 1536)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = c1.dump(hs_bytes->c0c1 + 1, 1536)) != srs_success) {
+        return srs_error_wrap(err, "dump c1");
     }
     
     // verify c1
     bool is_valid;
-    if ((ret = c1.c1_validate_digest(is_valid)) != ERROR_SUCCESS || !is_valid) {
-        ret = ERROR_RTMP_TRY_SIMPLE_HS;
-        return ret;
+    if ((err = c1.c1_validate_digest(is_valid)) != srs_success || !is_valid) {
+        srs_freep(err);
+        return srs_error_new(ERROR_RTMP_TRY_SIMPLE_HS, "try simple handshake");
     }
     
-    if ((ret = io->write(hs_bytes->c0c1, 1537, &nsize)) != ERROR_SUCCESS) {
-        srs_warn("write c0c1 failed. ret=%d", ret);
-        return ret;
+    if ((err = io->write(hs_bytes->c0c1, 1537, &nsize)) != srs_success) {
+        return srs_error_wrap(err, "write c0c1");
     }
-    srs_verbose("write c0c1 success.");
     
     // s0s1s2
-    if ((ret = hs_bytes->read_s0s1s2(io)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = hs_bytes->read_s0s1s2(io)) != srs_success) {
+        return srs_error_wrap(err, "read s0s1s2");
     }
     
     // plain text required.
     if (hs_bytes->s0s1s2[0] != 0x03) {
-        ret = ERROR_RTMP_HANDSHAKE;
-        srs_warn("handshake failed, plain text required. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_HANDSHAKE,  "handshake failed, plain text required, version=%X", (uint8_t)hs_bytes->s0s1s2[0]);
     }
     
     // verify s1s2
     c1s1 s1;
-    if ((ret = s1.parse(hs_bytes->s0s1s2 + 1, 1536, c1.schema())) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = s1.parse(hs_bytes->s0s1s2 + 1, 1536, c1.schema())) != srs_success) {
+        return srs_error_wrap(err, "parse s1");
     }
     
     // never verify the s1,
@@ -1436,27 +1332,25 @@ int SrsComplexHandshake::handshake_with_server(SrsHandshakeBytes* hs_bytes, ISrs
     // TODO: FIXME: find the handshake schema of nginx-rtmp.
     
     // c2
-    if ((ret = hs_bytes->create_c2()) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = hs_bytes->create_c2()) != srs_success) {
+        return srs_error_wrap(err, "create c2");
     }
     
     c2s2 c2;
-    if ((ret = c2.c2_create(&s1)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = c2.c2_create(&s1)) != srs_success) {
+        return srs_error_wrap(err, "create c2");
     }
     
-    if ((ret = c2.dump(hs_bytes->c2, 1536)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = c2.dump(hs_bytes->c2, 1536)) != srs_success) {
+        return srs_error_wrap(err, "dump c2");
     }
-    if ((ret = io->write(hs_bytes->c2, 1536, &nsize)) != ERROR_SUCCESS) {
-        srs_warn("complex handshake write c2 failed. ret=%d", ret);
-        return ret;
+    if ((err = io->write(hs_bytes->c2, 1536, &nsize)) != srs_success) {
+        return srs_error_wrap(err, "write c2");
     }
-    srs_verbose("complex handshake write c2 success.");
     
     srs_trace("complex handshake success.");
     
-    return ret;
+    return err;
 }
 #endif
 
diff --git a/trunk/src/protocol/srs_rtmp_handshake.hpp b/trunk/src/protocol/srs_rtmp_handshake.hpp
index 3e9d22ae7..70051f123 100644
--- a/trunk/src/protocol/srs_rtmp_handshake.hpp
+++ b/trunk/src/protocol/srs_rtmp_handshake.hpp
@@ -42,8 +42,8 @@ namespace _srs_internal
 #define SRS_OpensslHashSize 512
     extern uint8_t SrsGenuineFMSKey[];
     extern uint8_t SrsGenuineFPKey[];
-    int openssl_HMACsha256(const void* key, int key_size, const void* data, int data_size, void* digest);
-    int openssl_generate_key(char* public_key, int32_t size);
+    srs_error_t openssl_HMACsha256(const void* key, int key_size, const void* data, int data_size, void* digest);
+    srs_error_t openssl_generate_key(char* public_key, int32_t size);
     
     /**
      * the DH wrapper.
@@ -64,7 +64,7 @@ namespace _srs_internal
          *       sometimes openssl generate 127bytes public key.
          *       default to false to donot ensure.
          */
-        virtual int initialize(bool ensure_128bytes_public_key = false);
+        virtual srs_error_t initialize(bool ensure_128bytes_public_key = false);
         /**
          * copy the public key.
          * @param pkey the bytes to copy the public key.
@@ -72,7 +72,7 @@ namespace _srs_internal
          *       user should never ignore this size.
          * @remark, when ensure_128bytes_public_key, the size always 128.
          */
-        virtual int copy_public_key(char* pkey, int32_t& pkey_size);
+        virtual srs_error_t copy_public_key(char* pkey, int32_t& pkey_size);
         /**
          * generate and copy the shared key.
          * generate the shared key with peer public key.
@@ -82,9 +82,9 @@ namespace _srs_internal
          * @param skey_size the max shared key size, output the actual shared key size.
          *       user should never ignore this size.
          */
-        virtual int copy_shared_key(const char* ppkey, int32_t ppkey_size, char* skey, int32_t& skey_size);
+        virtual srs_error_t copy_shared_key(const char* ppkey, int32_t ppkey_size, char* skey, int32_t& skey_size);
     private:
-        virtual int do_initialize();
+        virtual srs_error_t do_initialize();
     };
     /**
      * the schema type.
@@ -137,7 +137,7 @@ namespace _srs_internal
         // parse key block from c1s1.
         // if created, user must free it by srs_key_block_free
         // @stream contains c1s1_key_bytes the key start bytes
-        int parse(SrsBuffer* stream);
+        srs_error_t parse(SrsBuffer* stream);
     private:
         // calc the offset of key,
         // the key->offset cannot be used as the offset of key.
@@ -175,7 +175,7 @@ namespace _srs_internal
         // parse digest block from c1s1.
         // if created, user must free it by srs_digest_block_free
         // @stream contains c1s1_digest_bytes the digest start bytes
-        int parse(SrsBuffer* stream);
+        srs_error_t parse(SrsBuffer* stream);
     private:
         // calc the offset of digest,
         // the key->offset cannot be used as the offset of digest.
@@ -214,12 +214,12 @@ namespace _srs_internal
          * copy to bytes.
          * @param size must be 1536.
          */
-        virtual int dump(c1s1* owner, char* _c1s1, int size);
+        virtual srs_error_t dump(c1s1* owner, char* _c1s1, int size);
         /**
          * server: parse the c1s1, discovery the key and digest by schema.
          * use the c1_validate_digest() to valid the digest of c1.
          */
-        virtual int parse(char* _c1s1, int size) = 0;
+        virtual srs_error_t parse(char* _c1s1, int size) = 0;
     public:
         /**
          * client: create and sign c1 by schema.
@@ -236,11 +236,11 @@ namespace _srs_internal
          *        digest-data = calc_c1_digest(c1, schema)
          *        copy digest-data to c1
          */
-        virtual int c1_create(c1s1* owner);
+        virtual srs_error_t c1_create(c1s1* owner);
         /**
          * server: validate the parsed c1 schema
          */
-        virtual int c1_validate_digest(c1s1* owner, bool& is_valid);
+        virtual srs_error_t c1_validate_digest(c1s1* owner, bool& is_valid);
         /**
          * server: create and sign the s1 from c1.
          *       // decode c1 try schema0 then schema1
@@ -268,25 +268,25 @@ namespace _srs_internal
          *       copy s1-digest-data and s1-key-data to s1.
          * @param c1, to get the peer_pub_key of client.
          */
-        virtual int s1_create(c1s1* owner, c1s1* c1);
+        virtual srs_error_t s1_create(c1s1* owner, c1s1* c1);
         /**
          * server: validate the parsed s1 schema
          */
-        virtual int s1_validate_digest(c1s1* owner, bool& is_valid);
+        virtual srs_error_t s1_validate_digest(c1s1* owner, bool& is_valid);
     public:
         /**
          * calc the digest for c1
          */
-        virtual int calc_c1_digest(c1s1* owner, char*& c1_digest);
+        virtual srs_error_t calc_c1_digest(c1s1* owner, char*& c1_digest);
         /**
          * calc the digest for s1
          */
-        virtual int calc_s1_digest(c1s1* owner, char*& s1_digest);
+        virtual srs_error_t calc_s1_digest(c1s1* owner, char*& s1_digest);
         /**
          * copy whole c1s1 to bytes.
          * @param size must always be 1536 with digest, and 1504 without digest.
          */
-        virtual int copy_to(c1s1* owner, char* bytes, int size, bool with_digest) = 0;
+        virtual srs_error_t copy_to(c1s1* owner, char* bytes, int size, bool with_digest) = 0;
         /**
          * copy time and version to stream.
          */
@@ -313,9 +313,9 @@ namespace _srs_internal
         virtual ~c1s1_strategy_schema0();
     public:
         virtual srs_schema_type schema();
-        virtual int parse(char* _c1s1, int size);
+        virtual srs_error_t parse(char* _c1s1, int size);
     public:
-        virtual int copy_to(c1s1* owner, char* bytes, int size, bool with_digest);
+        virtual srs_error_t copy_to(c1s1* owner, char* bytes, int size, bool with_digest);
     };
     
     /**
@@ -330,9 +330,9 @@ namespace _srs_internal
         virtual ~c1s1_strategy_schema1();
     public:
         virtual srs_schema_type schema();
-        virtual int parse(char* _c1s1, int size);
+        virtual srs_error_t parse(char* _c1s1, int size);
     public:
-        virtual int copy_to(c1s1* owner, char* bytes, int size, bool with_digest);
+        virtual srs_error_t copy_to(c1s1* owner, char* bytes, int size, bool with_digest);
     };
     
     /**
@@ -378,14 +378,14 @@ namespace _srs_internal
          * copy to bytes.
          * @param size, must always be 1536.
          */
-        virtual int dump(char* _c1s1, int size);
+        virtual srs_error_t dump(char* _c1s1, int size);
         /**
          * server: parse the c1s1, discovery the key and digest by schema.
          * @param size, must always be 1536.
          * use the c1_validate_digest() to valid the digest of c1.
          * use the s1_validate_digest() to valid the digest of s1.
          */
-        virtual int parse(char* _c1s1, int size, srs_schema_type _schema);
+        virtual srs_error_t parse(char* _c1s1, int size, srs_schema_type _schema);
     public:
         /**
          * client: create and sign c1 by schema.
@@ -402,11 +402,11 @@ namespace _srs_internal
          *        digest-data = calc_c1_digest(c1, schema)
          *        copy digest-data to c1
          */
-        virtual int c1_create(srs_schema_type _schema);
+        virtual srs_error_t c1_create(srs_schema_type _schema);
         /**
          * server: validate the parsed c1 schema
          */
-        virtual int c1_validate_digest(bool& is_valid);
+        virtual srs_error_t c1_validate_digest(bool& is_valid);
     public:
         /**
          * server: create and sign the s1 from c1.
@@ -434,11 +434,11 @@ namespace _srs_internal
          *       s1-digest-data = HMACsha256(c1s1-joined, FMSKey, 36)
          *       copy s1-digest-data and s1-key-data to s1.
          */
-        virtual int s1_create(c1s1* c1);
+        virtual srs_error_t s1_create(c1s1* c1);
         /**
          * server: validate the parsed s1 schema
          */
-        virtual int s1_validate_digest(bool& is_valid);
+        virtual srs_error_t s1_validate_digest(bool& is_valid);
     };
     
     /**
@@ -460,12 +460,12 @@ namespace _srs_internal
          * copy to bytes.
          * @param size, must always be 1536.
          */
-        virtual int dump(char* _c2s2, int size);
+        virtual srs_error_t dump(char* _c2s2, int size);
         /**
          * parse the c2s2
          * @param size, must always be 1536.
          */
-        virtual int parse(char* _c2s2, int size);
+        virtual srs_error_t parse(char* _c2s2, int size);
     public:
         /**
          * create c2.
@@ -475,12 +475,12 @@ namespace _srs_internal
          * temp-key = HMACsha256(s1-digest, FPKey, 62)
          * c2-digest-data = HMACsha256(c2-random-data, temp-key, 32)
          */
-        virtual int c2_create(c1s1* s1);
+        virtual srs_error_t c2_create(c1s1* s1);
         
         /**
          * validate the c2 from client.
          */
-        virtual int c2_validate(c1s1* s1, bool& is_valid);
+        virtual srs_error_t c2_validate(c1s1* s1, bool& is_valid);
     public:
         /**
          * create s2.
@@ -490,12 +490,12 @@ namespace _srs_internal
          * temp-key = HMACsha256(c1-digest, FMSKey, 68)
          * s2-digest-data = HMACsha256(s2-random-data, temp-key, 32)
          */
-        virtual int s2_create(c1s1* c1);
+        virtual srs_error_t s2_create(c1s1* c1);
         
         /**
          * validate the s2 from server.
          */
-        virtual int s2_validate(c1s1* c1, bool& is_valid);
+        virtual srs_error_t s2_validate(c1s1* c1, bool& is_valid);
     };
 }
 
@@ -515,8 +515,8 @@ public:
     /**
      * simple handshake.
      */
-    virtual int handshake_with_client(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io);
-    virtual int handshake_with_server(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io);
+    virtual srs_error_t handshake_with_client(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io);
+    virtual srs_error_t handshake_with_server(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io);
 };
 
 /**
@@ -537,8 +537,8 @@ public:
      *     try simple handshake if error is ERROR_RTMP_TRY_SIMPLE_HS,
      *     otherwise, disconnect
      */
-    virtual int handshake_with_client(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io);
-    virtual int handshake_with_server(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io);
+    virtual srs_error_t handshake_with_client(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io);
+    virtual srs_error_t handshake_with_server(SrsHandshakeBytes* hs_bytes, ISrsProtocolReaderWriter* io);
 };
 
 #endif
diff --git a/trunk/src/protocol/srs_rtmp_stack.cpp b/trunk/src/protocol/srs_rtmp_stack.cpp
index de78e2ccf..7dfe8d788 100644
--- a/trunk/src/protocol/srs_rtmp_stack.cpp
+++ b/trunk/src/protocol/srs_rtmp_stack.cpp
@@ -137,48 +137,34 @@ SrsPacket::~SrsPacket()
 {
 }
 
-int SrsPacket::encode(int& psize, char*& ppayload)
+srs_error_t SrsPacket::encode(int& psize, char*& ppayload)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     int size = get_size();
     char* payload = NULL;
     
-    SrsBuffer stream;
-    
     if (size > 0) {
         payload = new char[size];
         
-        if ((ret = stream.initialize(payload, size)) != ERROR_SUCCESS) {
-            srs_error("initialize the stream failed. ret=%d", ret);
+        SrsBuffer* stream = new SrsBuffer(payload, size);
+        SrsAutoFree(SrsBuffer, stream);
+        
+        if ((err = encode_packet(stream)) != srs_success) {
             srs_freepa(payload);
-            return ret;
+            return srs_error_wrap(err, "encode packet");
         }
     }
     
-    if ((ret = encode_packet(&stream)) != ERROR_SUCCESS) {
-        srs_error("encode the packet failed. ret=%d", ret);
-        srs_freepa(payload);
-        return ret;
-    }
-    
     psize = size;
     ppayload = payload;
-    srs_verbose("encode the packet success. size=%d", size);
     
-    return ret;
+    return err;
 }
 
-int SrsPacket::decode(SrsBuffer* stream)
+srs_error_t SrsPacket::decode(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
-    
-    srs_assert(stream != NULL);
-    
-    ret = ERROR_SYSTEM_PACKET_INVALID;
-    srs_error("current packet is not support to decode. ret=%d", ret);
-    
-    return ret;
+    return srs_error_new(ERROR_SYSTEM_PACKET_INVALID, "decode");
 }
 
 int SrsPacket::get_prefer_cid()
@@ -196,16 +182,9 @@ int SrsPacket::get_size()
     return 0;
 }
 
-int SrsPacket::encode_packet(SrsBuffer* stream)
+srs_error_t SrsPacket::encode_packet(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
-    
-    srs_assert(stream != NULL);
-    
-    ret = ERROR_SYSTEM_PACKET_INVALID;
-    srs_error("current packet is not support to encode. ret=%d", ret);
-    
-    return ret;
+    return srs_error_new(ERROR_SYSTEM_PACKET_INVALID, "encode");
 }
 
 SrsProtocol::AckWindowSize::AckWindowSize()
@@ -289,12 +268,12 @@ void SrsProtocol::set_auto_response(bool v)
     auto_response_when_recv = v;
 }
 
-int SrsProtocol::manual_response_flush()
+srs_error_t SrsProtocol::manual_response_flush()
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     if (manual_response_queue.empty()) {
-        return ret;
+        return err;
     }
     
     std::vector<SrsPacket*>::iterator it;
@@ -305,12 +284,12 @@ int SrsProtocol::manual_response_flush()
         it = manual_response_queue.erase(it);
         
         // use underlayer api to send, donot flush again.
-        if ((ret = do_send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            return ret;
+        if ((err = do_send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send packet");
         }
     }
     
-    return ret;
+    return err;
 }
 
 #ifdef SRS_PERF_MERGED_READ
@@ -355,32 +334,27 @@ int64_t SrsProtocol::get_send_bytes()
     return skt->get_send_bytes();
 }
 
-int SrsProtocol::set_in_window_ack_size(int ack_size)
+srs_error_t SrsProtocol::set_in_window_ack_size(int ack_size)
 {
     in_ack_size.window = ack_size;
-    return ERROR_SUCCESS;
+    return srs_success;
 }
 
-int SrsProtocol::recv_message(SrsCommonMessage** pmsg)
+srs_error_t SrsProtocol::recv_message(SrsCommonMessage** pmsg)
 {
     *pmsg = NULL;
     
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     while (true) {
         SrsCommonMessage* msg = NULL;
         
-        if ((ret = recv_interlaced_message(&msg)) != ERROR_SUCCESS) {
-            if (ret != ERROR_SOCKET_TIMEOUT && !srs_is_client_gracefully_close(ret)) {
-                srs_error("recv interlaced message failed. ret=%d", ret);
-            }
+        if ((err = recv_interlaced_message(&msg)) != srs_success) {
             srs_freep(msg);
-            return ret;
+            return srs_error_wrap(err, "recv interlaced message");
         }
-        srs_verbose("entire msg received");
         
         if (!msg) {
-            srs_info("got empty message without error.");
             continue;
         }
         
@@ -392,58 +366,46 @@ int SrsProtocol::recv_message(SrsCommonMessage** pmsg)
             continue;
         }
         
-        if ((ret = on_recv_message(msg)) != ERROR_SUCCESS) {
-            srs_error("hook the received msg failed. ret=%d", ret);
+        if ((err = on_recv_message(msg)) != srs_success) {
             srs_freep(msg);
-            return ret;
+            return srs_error_wrap(err, "on recv message");
         }
         
-        srs_verbose("got a msg, cid=%d, type=%d, size=%d, time=%" PRId64,
-                    msg->header.perfer_cid, msg->header.message_type, msg->header.payload_length,
-                    msg->header.timestamp);
         *pmsg = msg;
         break;
     }
     
-    return ret;
+    return err;
 }
 
-int SrsProtocol::decode_message(SrsCommonMessage* msg, SrsPacket** ppacket)
+srs_error_t SrsProtocol::decode_message(SrsCommonMessage* msg, SrsPacket** ppacket)
 {
     *ppacket = NULL;
     
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     srs_assert(msg != NULL);
     srs_assert(msg->payload != NULL);
     srs_assert(msg->size > 0);
     
-    SrsBuffer stream;
-    
-    // initialize the decode stream for all message,
-    // it's ok for the initialize if fast and without memory copy.
-    if ((ret = stream.initialize(msg->payload, msg->size)) != ERROR_SUCCESS) {
-        srs_error("initialize stream failed. ret=%d", ret);
-        return ret;
-    }
-    srs_verbose("decode stream initialized success");
+    SrsBuffer stream(msg->payload, msg->size);
     
     // decode the packet.
     SrsPacket* packet = NULL;
-    if ((ret = do_decode_message(msg->header, &stream, &packet)) != ERROR_SUCCESS) {
+    if ((err = do_decode_message(msg->header, &stream, &packet)) != srs_success) {
         srs_freep(packet);
-        return ret;
+        return srs_error_wrap(err, "decode message");
     }
     
     // set to output ppacket only when success.
     *ppacket = packet;
     
-    return ret;
+    return err;
 }
 
-int SrsProtocol::do_send_messages(SrsSharedPtrMessage** msgs, int nb_msgs)
+srs_error_t SrsProtocol::do_send_messages(SrsSharedPtrMessage** msgs, int nb_msgs)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
 #ifdef SRS_PERF_COMPLEX_SEND
     int iov_index = 0;
@@ -463,7 +425,6 @@ int SrsProtocol::do_send_messages(SrsSharedPtrMessage** msgs, int nb_msgs)
         
         // ignore empty message.
         if (!msg->payload || msg->size <= 0) {
-            srs_info("ignore empty message.");
             continue;
         }
         
@@ -495,9 +456,7 @@ int SrsProtocol::do_send_messages(SrsSharedPtrMessage** msgs, int nb_msgs)
             // for we donot know how many messges maybe to send entirely,
             // we just alloc the iovs, it's ok.
             if (iov_index >= nb_out_iovs - 2) {
-                srs_warn("resize iovs %d => %d, max_msgs=%d",
-                         nb_out_iovs, nb_out_iovs + SRS_CONSTS_IOVS_MAX,
-                         SRS_PERF_MW_MSGS);
+                srs_warn("resize iovs %d => %d, max_msgs=%d", nb_out_iovs, nb_out_iovs + SRS_CONSTS_IOVS_MAX, SRS_PERF_MW_MSGS);
                 
                 nb_out_iovs += SRS_CONSTS_IOVS_MAX;
                 int realloc_size = sizeof(iovec) * nb_out_iovs;
@@ -519,15 +478,14 @@ int SrsProtocol::do_send_messages(SrsSharedPtrMessage** msgs, int nb_msgs)
             if (c0c3_left < SRS_CONSTS_RTMP_MAX_FMT0_HEADER_SIZE) {
                 // only warn once for a connection.
                 if (!warned_c0c3_cache_dry) {
-                    srs_warn("c0c3 cache header too small, recoment to %d",
-                             SRS_CONSTS_C0C3_HEADERS_MAX + SRS_CONSTS_RTMP_MAX_FMT0_HEADER_SIZE);
+                    srs_warn("c0c3 cache header too small, recoment to %d", SRS_CONSTS_C0C3_HEADERS_MAX + SRS_CONSTS_RTMP_MAX_FMT0_HEADER_SIZE);
                     warned_c0c3_cache_dry = true;
                 }
                 
                 // when c0c3 cache dry,
                 // sendout all messages and reset the cache, then send again.
-                if ((ret = do_iovs_send(out_iovs, iov_index)) != ERROR_SUCCESS) {
-                    return ret;
+                if ((err = do_iovs_send(out_iovs, iov_index)) != srs_success) {
+                    return srs_error_wrap(err, "send iovs");
                 }
                 
                 // reset caches, while these cache ensure
@@ -544,10 +502,8 @@ int SrsProtocol::do_send_messages(SrsSharedPtrMessage** msgs, int nb_msgs)
     // maybe the iovs already sendout when c0c3 cache dry,
     // so just ignore when no iovs to send.
     if (iov_index <= 0) {
-        return ret;
+        return err;
     }
-    srs_info("mw %d msgs in %d iovs, max_msgs=%d, nb_out_iovs=%d",
-             nb_msgs, iov_index, SRS_PERF_MW_MSGS, nb_out_iovs);
     
     return do_iovs_send(out_iovs, iov_index);
 #else
@@ -562,7 +518,6 @@ int SrsProtocol::do_send_messages(SrsSharedPtrMessage** msgs, int nb_msgs)
         
         // ignore empty message.
         if (!msg->payload || msg->size <= 0) {
-            srs_info("ignore empty message.");
             continue;
         }
         
@@ -594,42 +549,38 @@ int SrsProtocol::do_send_messages(SrsSharedPtrMessage** msgs, int nb_msgs)
             // consume sendout bytes.
             p += payload_size;
             
-            if ((ret = skt->writev(iovs, 2, NULL)) != ERROR_SUCCESS) {
-                if (!srs_is_client_gracefully_close(ret)) {
-                    srs_error("send packet with writev failed. ret=%d", ret);
-                }
-                return ret;
+            if ((er = skt->writev(iovs, 2, NULL)) != srs_success) {
+                return srs_error_wrap(err, "writev");
             }
         }
     }
     
-    return ret;
+    return err;
 #endif
 }
 
-int SrsProtocol::do_iovs_send(iovec* iovs, int size)
+srs_error_t SrsProtocol::do_iovs_send(iovec* iovs, int size)
 {
     return srs_write_large_iovs(skt, iovs, size);
 }
 
-int SrsProtocol::do_send_and_free_packet(SrsPacket* packet, int stream_id)
+srs_error_t SrsProtocol::do_send_and_free_packet(SrsPacket* packet, int stream_id)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     srs_assert(packet);
     SrsAutoFree(SrsPacket, packet);
     
     int size = 0;
     char* payload = NULL;
-    if ((ret = packet->encode(size, payload)) != ERROR_SUCCESS) {
-        srs_error("encode RTMP packet to bytes oriented RTMP message failed. ret=%d", ret);
-        return ret;
+    if ((err = packet->encode(size, payload)) != srs_success) {
+        return srs_error_wrap(err, "encode packet");
     }
     
     // encode packet to payload and size.
     if (size <= 0 || payload == NULL) {
         srs_warn("packet is empty, ignore empty message.");
-        return ret;
+        return err;
     }
     
     // to message
@@ -639,18 +590,22 @@ int SrsProtocol::do_send_and_free_packet(SrsPacket* packet, int stream_id)
     header.stream_id = stream_id;
     header.perfer_cid = packet->get_prefer_cid();
     
-    ret = do_simple_send(&header, payload, size);
+    err = do_simple_send(&header, payload, size);
     srs_freepa(payload);
-    if (ret == ERROR_SUCCESS) {
-        ret = on_send_packet(&header, packet);
+    if (err != srs_success) {
+        return srs_error_wrap(err, "simple send");
     }
     
-    return ret;
+    if ((err = on_send_packet(&header, packet)) != srs_success) {
+        return srs_error_wrap(err, "on send packet");
+    }
+    
+    return err;
 }
 
-int SrsProtocol::do_simple_send(SrsMessageHeader* mh, char* payload, int size)
+srs_error_t SrsProtocol::do_simple_send(SrsMessageHeader* mh, char* payload, int size)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // we directly send out the packet,
     // use very simple algorithm, not very fast,
@@ -661,14 +616,9 @@ int SrsProtocol::do_simple_send(SrsMessageHeader* mh, char* payload, int size)
     while (p < end) {
         int nbh = 0;
         if (p == payload) {
-            nbh = srs_chunk_header_c0(
-                                      mh->perfer_cid, (uint32_t)mh->timestamp, mh->payload_length,
-                                      mh->message_type, mh->stream_id,
-                                      c0c3, sizeof(c0c3));
+            nbh = srs_chunk_header_c0(mh->perfer_cid, (uint32_t)mh->timestamp, mh->payload_length, mh->message_type, mh->stream_id, c0c3, sizeof(c0c3));
         } else {
-            nbh = srs_chunk_header_c3(
-                                      mh->perfer_cid, (uint32_t)mh->timestamp,
-                                      c0c3, sizeof(c0c3));
+            nbh = srs_chunk_header_c3(mh->perfer_cid, (uint32_t)mh->timestamp, c0c3, sizeof(c0c3));
         }
         srs_assert(nbh > 0);;
         
@@ -681,50 +631,40 @@ int SrsProtocol::do_simple_send(SrsMessageHeader* mh, char* payload, int size)
         iovs[1].iov_len = payload_size;
         p += payload_size;
         
-        if ((ret = skt->writev(iovs, 2, NULL)) != ERROR_SUCCESS) {
-            if (!srs_is_client_gracefully_close(ret)) {
-                srs_error("send packet with writev failed. ret=%d", ret);
-            }
-            return ret;
+        if ((err = skt->writev(iovs, 2, NULL)) != srs_success) {
+            return srs_error_wrap(err, "writev packet");
         }
     }
     
-    return ret;
+    return err;
 }
 
-int SrsProtocol::do_decode_message(SrsMessageHeader& header, SrsBuffer* stream, SrsPacket** ppacket)
+srs_error_t SrsProtocol::do_decode_message(SrsMessageHeader& header, SrsBuffer* stream, SrsPacket** ppacket)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     SrsPacket* packet = NULL;
     
     // decode specified packet type
     if (header.is_amf0_command() || header.is_amf3_command() || header.is_amf0_data() || header.is_amf3_data()) {
-        srs_verbose("start to decode AMF0/AMF3 command message.");
-        
         // skip 1bytes to decode the amf3 command.
         if (header.is_amf3_command() && stream->require(1)) {
-            srs_verbose("skip 1bytes to decode AMF3 command");
             stream->skip(1);
         }
         
         // amf0 command message.
         // need to read the command name.
         std::string command;
-        if ((ret = srs_amf0_read_string(stream, command)) != ERROR_SUCCESS) {
-            srs_error("decode AMF0/AMF3 command name failed. ret=%d", ret);
-            return ret;
+        if ((err = srs_amf0_read_string(stream, command)) != srs_success) {
+            return srs_error_wrap(err, "decode command name");
         }
-        srs_verbose("AMF0/AMF3 command message, command_name=%s", command.c_str());
         
         // result/error packet
         if (command == RTMP_AMF0_COMMAND_RESULT || command == RTMP_AMF0_COMMAND_ERROR) {
             double transactionId = 0.0;
-            if ((ret = srs_amf0_read_number(stream, transactionId)) != ERROR_SUCCESS) {
-                srs_error("decode AMF0/AMF3 transcationId failed. ret=%d", ret);
-                return ret;
+            if ((err = srs_amf0_read_number(stream, transactionId)) != srs_success) {
+                return srs_error_wrap(err, "decode tid for %s", command.c_str());
             }
-            srs_verbose("AMF0/AMF3 command id, transcationId=%.2f", transactionId);
             
             // reset stream, for header read completed.
             stream->skip(-1 * stream->pos());
@@ -734,34 +674,27 @@ int SrsProtocol::do_decode_message(SrsMessageHeader& header, SrsBuffer* stream,
             
             // find the call name
             if (requests.find(transactionId) == requests.end()) {
-                ret = ERROR_RTMP_NO_REQUEST;
-                srs_error("decode AMF0/AMF3 request failed. ret=%d", ret);
-                return ret;
+                return srs_error_new(ERROR_RTMP_NO_REQUEST, "find request for command=%s, tid=%.2f", command.c_str(), transactionId);
             }
             
             std::string request_name = requests[transactionId];
-            srs_verbose("AMF0/AMF3 request parsed. request_name=%s", request_name.c_str());
-            
             if (request_name == RTMP_AMF0_COMMAND_CONNECT) {
-                srs_info("decode the AMF0/AMF3 response command(%s message).", request_name.c_str());
                 *ppacket = packet = new SrsConnectAppResPacket();
                 return packet->decode(stream);
             } else if (request_name == RTMP_AMF0_COMMAND_CREATE_STREAM) {
-                srs_info("decode the AMF0/AMF3 response command(%s message).", request_name.c_str());
                 *ppacket = packet = new SrsCreateStreamResPacket(0, 0);
                 return packet->decode(stream);
-            } else if (request_name == RTMP_AMF0_COMMAND_RELEASE_STREAM
-                       || request_name == RTMP_AMF0_COMMAND_FC_PUBLISH
-                       || request_name == RTMP_AMF0_COMMAND_UNPUBLISH) {
-                srs_info("decode the AMF0/AMF3 response command(%s message).", request_name.c_str());
+            } else if (request_name == RTMP_AMF0_COMMAND_RELEASE_STREAM) {
+                *ppacket = packet = new SrsFMLEStartResPacket(0);
+                return packet->decode(stream);
+            } else if (request_name == RTMP_AMF0_COMMAND_FC_PUBLISH) {
+                *ppacket = packet = new SrsFMLEStartResPacket(0);
+                return packet->decode(stream);
+            } else if (request_name == RTMP_AMF0_COMMAND_UNPUBLISH) {
                 *ppacket = packet = new SrsFMLEStartResPacket(0);
                 return packet->decode(stream);
             } else {
-                ret = ERROR_RTMP_NO_REQUEST;
-                srs_error("decode AMF0/AMF3 request failed. "
-                          "request_name=%s, transactionId=%.2f, ret=%d",
-                          request_name.c_str(), transactionId, ret);
-                return ret;
+                return srs_error_new(ERROR_RTMP_NO_REQUEST, "request=%s, tid=%.2f", request_name.c_str(), transactionId);
             }
         }
         
@@ -773,81 +706,89 @@ int SrsProtocol::do_decode_message(SrsMessageHeader& header, SrsBuffer* stream,
         
         // decode command object.
         if (command == RTMP_AMF0_COMMAND_CONNECT) {
-            srs_info("decode the AMF0/AMF3 command(connect vhost/app message).");
             *ppacket = packet = new SrsConnectAppPacket();
             return packet->decode(stream);
-        } else if(command == RTMP_AMF0_COMMAND_CREATE_STREAM) {
-            srs_info("decode the AMF0/AMF3 command(createStream message).");
+        } else if (command == RTMP_AMF0_COMMAND_CREATE_STREAM) {
             *ppacket = packet = new SrsCreateStreamPacket();
             return packet->decode(stream);
-        } else if(command == RTMP_AMF0_COMMAND_PLAY) {
-            srs_info("decode the AMF0/AMF3 command(paly message).");
+        } else if (command == RTMP_AMF0_COMMAND_PLAY) {
             *ppacket = packet = new SrsPlayPacket();
             return packet->decode(stream);
-        } else if(command == RTMP_AMF0_COMMAND_PAUSE) {
-            srs_info("decode the AMF0/AMF3 command(pause message).");
+        } else if (command == RTMP_AMF0_COMMAND_PAUSE) {
             *ppacket = packet = new SrsPausePacket();
             return packet->decode(stream);
-        } else if(command == RTMP_AMF0_COMMAND_RELEASE_STREAM) {
-            srs_info("decode the AMF0/AMF3 command(FMLE releaseStream message).");
+        } else if (command == RTMP_AMF0_COMMAND_RELEASE_STREAM) {
             *ppacket = packet = new SrsFMLEStartPacket();
             return packet->decode(stream);
-        } else if(command == RTMP_AMF0_COMMAND_FC_PUBLISH) {
-            srs_info("decode the AMF0/AMF3 command(FMLE FCPublish message).");
+        } else if (command == RTMP_AMF0_COMMAND_FC_PUBLISH) {
             *ppacket = packet = new SrsFMLEStartPacket();
             return packet->decode(stream);
-        } else if(command == RTMP_AMF0_COMMAND_PUBLISH) {
-            srs_info("decode the AMF0/AMF3 command(publish message).");
+        } else if (command == RTMP_AMF0_COMMAND_PUBLISH) {
             *ppacket = packet = new SrsPublishPacket();
             return packet->decode(stream);
-        } else if(command == RTMP_AMF0_COMMAND_UNPUBLISH) {
-            srs_info("decode the AMF0/AMF3 command(unpublish message).");
+        } else if (command == RTMP_AMF0_COMMAND_UNPUBLISH) {
             *ppacket = packet = new SrsFMLEStartPacket();
             return packet->decode(stream);
-        } else if(command == SRS_CONSTS_RTMP_SET_DATAFRAME || command == SRS_CONSTS_RTMP_ON_METADATA) {
-            srs_info("decode the AMF0/AMF3 data(onMetaData message).");
+        } else if (command == SRS_CONSTS_RTMP_SET_DATAFRAME) {
             *ppacket = packet = new SrsOnMetaDataPacket();
             return packet->decode(stream);
-        } else if(command == SRS_BW_CHECK_FINISHED
-                  || command == SRS_BW_CHECK_PLAYING
-                  || command == SRS_BW_CHECK_PUBLISHING
-                  || command == SRS_BW_CHECK_STARTING_PLAY
-                  || command == SRS_BW_CHECK_STARTING_PUBLISH
-                  || command == SRS_BW_CHECK_START_PLAY
-                  || command == SRS_BW_CHECK_START_PUBLISH
-                  || command == SRS_BW_CHECK_STOPPED_PLAY
-                  || command == SRS_BW_CHECK_STOP_PLAY
-                  || command == SRS_BW_CHECK_STOP_PUBLISH
-                  || command == SRS_BW_CHECK_STOPPED_PUBLISH
-                  || command == SRS_BW_CHECK_FINAL)
-        {
-            srs_info("decode the AMF0/AMF3 band width check message.");
+        } else if (command == SRS_CONSTS_RTMP_ON_METADATA) {
+            *ppacket = packet = new SrsOnMetaDataPacket();
+            return packet->decode(stream);
+        } else if (command == SRS_BW_CHECK_FINISHED) {
+            *ppacket = packet = new SrsBandwidthPacket();
+            return packet->decode(stream);
+        } else if (command == SRS_BW_CHECK_PLAYING) {
+            *ppacket = packet = new SrsBandwidthPacket();
+            return packet->decode(stream);
+        } else if (command == SRS_BW_CHECK_PUBLISHING) {
+            *ppacket = packet = new SrsBandwidthPacket();
+            return packet->decode(stream);
+        } else if (command == SRS_BW_CHECK_STARTING_PLAY) {
+            *ppacket = packet = new SrsBandwidthPacket();
+            return packet->decode(stream);
+        } else if (command == SRS_BW_CHECK_STARTING_PUBLISH) {
+            *ppacket = packet = new SrsBandwidthPacket();
+            return packet->decode(stream);
+        } else if (command == SRS_BW_CHECK_START_PLAY) {
+            *ppacket = packet = new SrsBandwidthPacket();
+            return packet->decode(stream);
+        } else if (command == SRS_BW_CHECK_START_PUBLISH) {
+            *ppacket = packet = new SrsBandwidthPacket();
+            return packet->decode(stream);
+        } else if (command == SRS_BW_CHECK_STOPPED_PLAY) {
+            *ppacket = packet = new SrsBandwidthPacket();
+            return packet->decode(stream);
+        } else if (command == SRS_BW_CHECK_STOP_PLAY) {
+            *ppacket = packet = new SrsBandwidthPacket();
+            return packet->decode(stream);
+        } else if (command == SRS_BW_CHECK_STOP_PUBLISH) {
+            *ppacket = packet = new SrsBandwidthPacket();
+            return packet->decode(stream);
+        } else if (command == SRS_BW_CHECK_STOPPED_PUBLISH) {
+            *ppacket = packet = new SrsBandwidthPacket();
+            return packet->decode(stream);
+        } else if (command == SRS_BW_CHECK_FINAL) {
             *ppacket = packet = new SrsBandwidthPacket();
             return packet->decode(stream);
         } else if (command == RTMP_AMF0_COMMAND_CLOSE_STREAM) {
-            srs_info("decode the AMF0/AMF3 closeStream message.");
             *ppacket = packet = new SrsCloseStreamPacket();
             return packet->decode(stream);
         } else if (header.is_amf0_command() || header.is_amf3_command()) {
-            srs_info("decode the AMF0/AMF3 call message.");
             *ppacket = packet = new SrsCallPacket();
             return packet->decode(stream);
         }
         
         // default packet to drop message.
-        srs_info("drop the AMF0/AMF3 command message, command_name=%s", command.c_str());
         *ppacket = packet = new SrsPacket();
-        return ret;
-    } else if(header.is_user_control_message()) {
-        srs_verbose("start to decode user control message.");
+        return err;
+    } else if (header.is_user_control_message()) {
         *ppacket = packet = new SrsUserControlPacket();
         return packet->decode(stream);
-    } else if(header.is_window_ackledgement_size()) {
-        srs_verbose("start to decode set ack window size message.");
+    } else if (header.is_window_ackledgement_size()) {
         *ppacket = packet = new SrsSetWindowAckSizePacket();
         return packet->decode(stream);
-    } else if(header.is_set_chunk_size()) {
-        srs_verbose("start to decode set chunk size message.");
+    } else if (header.is_set_chunk_size()) {
         *ppacket = packet = new SrsSetChunkSizePacket();
         return packet->decode(stream);
     } else {
@@ -856,15 +797,15 @@ int SrsProtocol::do_decode_message(SrsMessageHeader& header, SrsBuffer* stream,
         }
     }
     
-    return ret;
+    return err;
 }
 
-int SrsProtocol::send_and_free_message(SrsSharedPtrMessage* msg, int stream_id)
+srs_error_t SrsProtocol::send_and_free_message(SrsSharedPtrMessage* msg, int stream_id)
 {
     return send_and_free_messages(&msg, 1, stream_id);
 }
 
-int SrsProtocol::send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs, int stream_id)
+srs_error_t SrsProtocol::send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs, int stream_id)
 {
     // always not NULL msg.
     srs_assert(msgs);
@@ -887,7 +828,7 @@ int SrsProtocol::send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs,
     
     // donot use the auto free to free the msg,
     // for performance issue.
-    int ret = do_send_messages(msgs, nb_msgs);
+    srs_error_t err = do_send_messages(msgs, nb_msgs);
     
     for (int i = 0; i < nb_msgs; i++) {
         SrsSharedPtrMessage* msg = msgs[i];
@@ -895,50 +836,46 @@ int SrsProtocol::send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs,
     }
     
     // donot flush when send failed
-    if (ret != ERROR_SUCCESS) {
-        return ret;
+    if (err != srs_success) {
+        return srs_error_wrap(err, "send messages");
     }
     
     // flush messages in manual queue
-    if ((ret = manual_response_flush()) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = manual_response_flush()) != srs_success) {
+        return srs_error_wrap(err, "manual flush response");
     }
     
     print_debug_info();
     
-    return ret;
+    return err;
 }
 
-int SrsProtocol::send_and_free_packet(SrsPacket* packet, int stream_id)
+srs_error_t SrsProtocol::send_and_free_packet(SrsPacket* packet, int stream_id)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
-    if ((ret = do_send_and_free_packet(packet, stream_id)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = do_send_and_free_packet(packet, stream_id)) != srs_success) {
+        return srs_error_wrap(err, "send packet");
     }
     
     // flush messages in manual queue
-    if ((ret = manual_response_flush()) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = manual_response_flush()) != srs_success) {
+        return srs_error_wrap(err, "manual flush response");
     }
     
-    return ret;
+    return err;
 }
 
-int SrsProtocol::recv_interlaced_message(SrsCommonMessage** pmsg)
+srs_error_t SrsProtocol::recv_interlaced_message(SrsCommonMessage** pmsg)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // chunk stream basic header.
     char fmt = 0;
     int cid = 0;
-    if ((ret = read_basic_header(fmt, cid)) != ERROR_SUCCESS) {
-        if (ret != ERROR_SOCKET_TIMEOUT && !srs_is_client_gracefully_close(ret)) {
-            srs_error("read basic header failed. ret=%d", ret);
-        }
-        return ret;
+    if ((err = read_basic_header(fmt, cid)) != srs_success) {
+        return srs_error_wrap(err, "read basic header");
     }
-    srs_verbose("read basic header success. fmt=%d, cid=%d", fmt, cid);
     
     // the cid must not negative.
     srs_assert(cid >= 0);
@@ -949,13 +886,8 @@ int SrsProtocol::recv_interlaced_message(SrsCommonMessage** pmsg)
     // use chunk stream cache to get the chunk info.
     // @see https://github.com/ossrs/srs/issues/249
     if (cid < SRS_PERF_CHUNK_STREAM_CACHE) {
-        // chunk stream cache hit.
-        srs_verbose("cs-cache hit, cid=%d", cid);
         // already init, use it direclty
         chunk = cs_cache[cid];
-        srs_verbose("cached chunk stream: fmt=%d, cid=%d, size=%d, message(type=%d, size=%d, time=%" PRId64 ", sid=%d)",
-                    chunk->fmt, chunk->cid, (chunk->msg? chunk->msg->size : 0), chunk->header.message_type, chunk->header.payload_length,
-                    chunk->header.timestamp, chunk->header.stream_id);
     } else {
         // chunk stream cache miss, use map.
         if (chunk_streams.find(cid) == chunk_streams.end()) {
@@ -963,50 +895,29 @@ int SrsProtocol::recv_interlaced_message(SrsCommonMessage** pmsg)
             // set the perfer cid of chunk,
             // which will copy to the message received.
             chunk->header.perfer_cid = cid;
-            srs_verbose("cache new chunk stream: fmt=%d, cid=%d", fmt, cid);
         } else {
             chunk = chunk_streams[cid];
-            srs_verbose("cached chunk stream: fmt=%d, cid=%d, size=%d, message(type=%d, size=%d, time=%" PRId64 ", sid=%d)",
-                        chunk->fmt, chunk->cid, (chunk->msg? chunk->msg->size : 0), chunk->header.message_type, chunk->header.payload_length,
-                        chunk->header.timestamp, chunk->header.stream_id);
         }
     }
     
     // chunk stream message header
-    if ((ret = read_message_header(chunk, fmt)) != ERROR_SUCCESS) {
-        if (ret != ERROR_SOCKET_TIMEOUT && !srs_is_client_gracefully_close(ret)) {
-            srs_error("read message header failed. ret=%d", ret);
-        }
-        return ret;
+    if ((err = read_message_header(chunk, fmt)) != srs_success) {
+        return srs_error_wrap(err, "read message header");
     }
-    srs_verbose("read message header success. "
-                "fmt=%d, ext_time=%d, size=%d, message(type=%d, size=%d, time=%" PRId64 ", sid=%d)",
-                fmt, chunk->extended_timestamp, (chunk->msg? chunk->msg->size : 0), chunk->header.message_type,
-                chunk->header.payload_length, chunk->header.timestamp, chunk->header.stream_id);
     
     // read msg payload from chunk stream.
     SrsCommonMessage* msg = NULL;
-    if ((ret = read_message_payload(chunk, &msg)) != ERROR_SUCCESS) {
-        if (ret != ERROR_SOCKET_TIMEOUT && !srs_is_client_gracefully_close(ret)) {
-            srs_error("read message payload failed. ret=%d", ret);
-        }
-        return ret;
+    if ((err = read_message_payload(chunk, &msg)) != srs_success) {
+        return srs_error_wrap(err, "read message payload");
     }
     
     // not got an entire RTMP message, try next chunk.
     if (!msg) {
-        srs_verbose("get partial message success. size=%d, message(type=%d, size=%d, time=%" PRId64 ", sid=%d)",
-                    (msg? msg->size : (chunk->msg? chunk->msg->size : 0)), chunk->header.message_type, chunk->header.payload_length,
-                    chunk->header.timestamp, chunk->header.stream_id);
-        return ret;
+        return err;
     }
     
     *pmsg = msg;
-    srs_info("get entire message success. size=%d, message(type=%d, size=%d, time=%" PRId64 ", sid=%d)",
-             (msg? msg->size : (chunk->msg? chunk->msg->size : 0)), chunk->header.message_type, chunk->header.payload_length,
-             chunk->header.timestamp, chunk->header.stream_id);
-    
-    return ret;
+    return err;
 }
 
 /**
@@ -1053,15 +964,12 @@ int SrsProtocol::recv_interlaced_message(SrsCommonMessage** pmsg)
  * Chunk stream IDs with values 64-319 could be represented by both 2-
  * byte version and 3-byte version of this field.
  */
-int SrsProtocol::read_basic_header(char& fmt, int& cid)
+srs_error_t SrsProtocol::read_basic_header(char& fmt, int& cid)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
-    if ((ret = in_buffer->grow(skt, 1)) != ERROR_SUCCESS) {
-        if (ret != ERROR_SOCKET_TIMEOUT && !srs_is_client_gracefully_close(ret)) {
-            srs_error("read 1bytes basic header failed. required_size=%d, ret=%d", 1, ret);
-        }
-        return ret;
+    if ((err = in_buffer->grow(skt, 1)) != srs_success) {
+        return srs_error_wrap(err, "basic header requires 1 bytes");
     }
     
     fmt = in_buffer->read_1byte();
@@ -1070,41 +978,32 @@ int SrsProtocol::read_basic_header(char& fmt, int& cid)
     
     // 2-63, 1B chunk header
     if (cid > 1) {
-        srs_verbose("basic header parsed. fmt=%d, cid=%d", fmt, cid);
-        return ret;
+        return err;
     }
     
     // 64-319, 2B chunk header
     if (cid == 0) {
-        if ((ret = in_buffer->grow(skt, 1)) != ERROR_SUCCESS) {
-            if (ret != ERROR_SOCKET_TIMEOUT && !srs_is_client_gracefully_close(ret)) {
-                srs_error("read 2bytes basic header failed. required_size=%d, ret=%d", 1, ret);
-            }
-            return ret;
+        if ((err = in_buffer->grow(skt, 1)) != srs_success) {
+            return srs_error_wrap(err, "basic header requires 2 bytes");
         }
         
         cid = 64;
         cid += (uint8_t)in_buffer->read_1byte();
-        srs_verbose("2bytes basic header parsed. fmt=%d, cid=%d", fmt, cid);
         // 64-65599, 3B chunk header
     } else if (cid == 1) {
-        if ((ret = in_buffer->grow(skt, 2)) != ERROR_SUCCESS) {
-            if (ret != ERROR_SOCKET_TIMEOUT && !srs_is_client_gracefully_close(ret)) {
-                srs_error("read 3bytes basic header failed. required_size=%d, ret=%d", 2, ret);
-            }
-            return ret;
+        if ((err = in_buffer->grow(skt, 2)) != srs_success) {
+            return srs_error_wrap(err, "basic header requires 3 bytes");
         }
         
         cid = 64;
         cid += (uint8_t)in_buffer->read_1byte();
         cid += ((uint8_t)in_buffer->read_1byte()) * 256;
-        srs_verbose("3bytes basic header parsed. fmt=%d, cid=%d", fmt, cid);
     } else {
         srs_error("invalid path, impossible basic header.");
         srs_assert(false);
     }
     
-    return ret;
+    return err;
 }
 
 /**
@@ -1119,9 +1018,9 @@ int SrsProtocol::read_basic_header(char& fmt, int& cid)
  *   fmt=2, 0x8X
  *   fmt=3, 0xCX
  */
-int SrsProtocol::read_message_header(SrsChunkStream* chunk, char fmt)
+srs_error_t SrsProtocol::read_message_header(SrsChunkStream* chunk, char fmt)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     /**
      * we should not assert anything about fmt, for the first packet.
@@ -1163,38 +1062,27 @@ int SrsProtocol::read_message_header(SrsChunkStream* chunk, char fmt)
             srs_warn("accept cid=2, fmt=1 to make librtmp happy.");
         } else {
             // must be a RTMP protocol level error.
-            ret = ERROR_RTMP_CHUNK_START;
-            srs_error("chunk stream is fresh, fmt must be %d, actual is %d. cid=%d, ret=%d",
-                      RTMP_FMT_TYPE0, fmt, chunk->cid, ret);
-            return ret;
+            return srs_error_new(ERROR_RTMP_CHUNK_START, "chunk is fresh, fmt must be %d, actual is %d. cid=%d", RTMP_FMT_TYPE0, fmt, chunk->cid);
         }
     }
     
     // when exists cache msg, means got an partial message,
     // the fmt must not be type0 which means new message.
     if (chunk->msg && fmt == RTMP_FMT_TYPE0) {
-        ret = ERROR_RTMP_CHUNK_START;
-        srs_error("chunk stream exists, "
-                  "fmt must not be %d, actual is %d. ret=%d", RTMP_FMT_TYPE0, fmt, ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_CHUNK_START, "chunk exists, fmt must not be %d, actual is %d", RTMP_FMT_TYPE0, fmt);
     }
     
     // create msg when new chunk stream start
     if (!chunk->msg) {
         chunk->msg = new SrsCommonMessage();
-        srs_verbose("create message for new chunk, fmt=%d, cid=%d", fmt, chunk->cid);
     }
     
     // read message header from socket to buffer.
     static char mh_sizes[] = {11, 7, 3, 0};
     int mh_size = mh_sizes[(int)fmt];
-    srs_verbose("calc chunk message header size. fmt=%d, mh_size=%d", fmt, mh_size);
     
-    if (mh_size > 0 && (ret = in_buffer->grow(skt, mh_size)) != ERROR_SUCCESS) {
-        if (ret != ERROR_SOCKET_TIMEOUT && !srs_is_client_gracefully_close(ret)) {
-            srs_error("read %dbytes message header failed. ret=%d", mh_size, ret);
-        }
-        return ret;
+    if (mh_size > 0 && (err = in_buffer->grow(skt, mh_size)) != srs_success) {
+        return srs_error_wrap(err, "read %d bytes message header", mh_size);
     }
     
     /**
@@ -1269,11 +1157,7 @@ int SrsProtocol::read_message_header(SrsChunkStream* chunk, char fmt)
             // for the fmt type1(stream_id not changed), user can change the payload
             // length(it's not allowed in the continue chunks).
             if (!is_first_chunk_of_msg && chunk->header.payload_length != payload_length) {
-                ret = ERROR_RTMP_PACKET_SIZE;
-                srs_error("msg exists in chunk cache, "
-                          "size=%d cannot change to %d, ret=%d",
-                          chunk->header.payload_length, payload_length, ret);
-                return ret;
+                return srs_error_new(ERROR_RTMP_PACKET_SIZE, "msg in chunk cache, size=%d cannot change to %d", chunk->header.payload_length, payload_length);
             }
             
             chunk->header.payload_length = payload_length;
@@ -1285,36 +1169,20 @@ int SrsProtocol::read_message_header(SrsChunkStream* chunk, char fmt)
                 pp[1] = *p++;
                 pp[2] = *p++;
                 pp[3] = *p++;
-                srs_verbose("header read completed. fmt=%d, mh_size=%d, ext_time=%d, time=%" PRId64 ", payload=%d, type=%d, sid=%d",
-                            fmt, mh_size, chunk->extended_timestamp, chunk->header.timestamp, chunk->header.payload_length,
-                            chunk->header.message_type, chunk->header.stream_id);
-            } else {
-                srs_verbose("header read completed. fmt=%d, mh_size=%d, ext_time=%d, time=%" PRId64 ", payload=%d, type=%d",
-                            fmt, mh_size, chunk->extended_timestamp, chunk->header.timestamp, chunk->header.payload_length,
-                            chunk->header.message_type);
             }
-        } else {
-            srs_verbose("header read completed. fmt=%d, mh_size=%d, ext_time=%d, time=%" PRId64 "",
-                        fmt, mh_size, chunk->extended_timestamp, chunk->header.timestamp);
         }
     } else {
         // update the timestamp even fmt=3 for first chunk packet
         if (is_first_chunk_of_msg && !chunk->extended_timestamp) {
             chunk->header.timestamp += chunk->header.timestamp_delta;
         }
-        srs_verbose("header read completed. fmt=%d, size=%d, ext_time=%d",
-                    fmt, mh_size, chunk->extended_timestamp);
     }
     
     // read extended-timestamp
     if (chunk->extended_timestamp) {
         mh_size += 4;
-        srs_verbose("read header ext time. fmt=%d, ext_time=%d, mh_size=%d", fmt, chunk->extended_timestamp, mh_size);
-        if ((ret = in_buffer->grow(skt, 4)) != ERROR_SUCCESS) {
-            if (ret != ERROR_SOCKET_TIMEOUT && !srs_is_client_gracefully_close(ret)) {
-                srs_error("read %dbytes message header failed. required_size=%d, ret=%d", mh_size, 4, ret);
-            }
-            return ret;
+        if ((err = in_buffer->grow(skt, 4)) != srs_success) {
+            return srs_error_wrap(err, "read 4 bytes ext timestamp");
         }
         // the ptr to the slice maybe invalid when grow()
         // reset the p to get 4bytes slice.
@@ -1361,11 +1229,9 @@ int SrsProtocol::read_message_header(SrsChunkStream* chunk, char fmt)
         if (!is_first_chunk_of_msg && chunk_timestamp > 0 && chunk_timestamp != timestamp) {
             mh_size -= 4;
             in_buffer->skip(-4);
-            srs_info("no 4bytes extended timestamp in the continued chunk");
         } else {
             chunk->header.timestamp = timestamp;
         }
-        srs_verbose("header read ext_time completed. time=%" PRId64 "", chunk->header.timestamp);
     }
     
     // the extended-timestamp must be unsigned-int,
@@ -1400,31 +1266,28 @@ int SrsProtocol::read_message_header(SrsChunkStream* chunk, char fmt)
     // increase the msg count, the chunk stream can accept fmt=1/2/3 message now.
     chunk->msg_count++;
     
-    return ret;
+    return err;
 }
 
-int SrsProtocol::read_message_payload(SrsChunkStream* chunk, SrsCommonMessage** pmsg)
+srs_error_t SrsProtocol::read_message_payload(SrsChunkStream* chunk, SrsCommonMessage** pmsg)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // empty message
     if (chunk->header.payload_length <= 0) {
-        srs_trace("get an empty RTMP "
-                  "message(type=%d, size=%d, time=%" PRId64 ", sid=%d)", chunk->header.message_type,
+        srs_trace("get an empty RTMP message(type=%d, size=%d, time=%" PRId64 ", sid=%d)", chunk->header.message_type,
                   chunk->header.payload_length, chunk->header.timestamp, chunk->header.stream_id);
         
         *pmsg = chunk->msg;
         chunk->msg = NULL;
         
-        return ret;
+        return err;
     }
     srs_assert(chunk->header.payload_length > 0);
     
     // the chunk payload size.
     int payload_size = chunk->header.payload_length - chunk->msg->size;
     payload_size = srs_min(payload_size, in_chunk_size);
-    srs_verbose("chunk payload size is %d, message_size=%d, received_size=%d, in_chunk_size=%d",
-                payload_size, chunk->header.payload_length, chunk->msg->size, in_chunk_size);
     
     // create msg payload if not initialized
     if (!chunk->msg->payload) {
@@ -1432,44 +1295,31 @@ int SrsProtocol::read_message_payload(SrsChunkStream* chunk, SrsCommonMessage**
     }
     
     // read payload to buffer
-    if ((ret = in_buffer->grow(skt, payload_size)) != ERROR_SUCCESS) {
-        if (ret != ERROR_SOCKET_TIMEOUT && !srs_is_client_gracefully_close(ret)) {
-            srs_error("read payload failed. required_size=%d, ret=%d", payload_size, ret);
-        }
-        return ret;
+    if ((err = in_buffer->grow(skt, payload_size)) != srs_success) {
+        return srs_error_wrap(err, "read %d bytes payload", payload_size);
     }
     memcpy(chunk->msg->payload + chunk->msg->size, in_buffer->read_slice(payload_size), payload_size);
     chunk->msg->size += payload_size;
     
-    srs_verbose("chunk payload read completed. payload_size=%d", payload_size);
-    
     // got entire RTMP message?
     if (chunk->header.payload_length == chunk->msg->size) {
         *pmsg = chunk->msg;
         chunk->msg = NULL;
-        srs_verbose("get entire RTMP message(type=%d, size=%d, time=%" PRId64 ", sid=%d)",
-                    chunk->header.message_type, chunk->header.payload_length,
-                    chunk->header.timestamp, chunk->header.stream_id);
-        return ret;
+        return err;
     }
     
-    srs_verbose("get partial RTMP message(type=%d, size=%d, time=%" PRId64 ", sid=%d), partial size=%d",
-                chunk->header.message_type, chunk->header.payload_length,
-                chunk->header.timestamp, chunk->header.stream_id,
-                chunk->msg->size);
-    
-    return ret;
+    return err;
 }
 
-int SrsProtocol::on_recv_message(SrsCommonMessage* msg)
+srs_error_t SrsProtocol::on_recv_message(SrsCommonMessage* msg)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     srs_assert(msg != NULL);
     
     // try to response acknowledgement
-    if ((ret = response_acknowledgement_message()) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = response_acknowledgement_message()) != srs_success) {
+        return srs_error_wrap(err, "response ack");
     }
     
     SrsPacket* packet = NULL;
@@ -1477,17 +1327,15 @@ int SrsProtocol::on_recv_message(SrsCommonMessage* msg)
         case RTMP_MSG_SetChunkSize:
         case RTMP_MSG_UserControlMessage:
         case RTMP_MSG_WindowAcknowledgementSize:
-            if ((ret = decode_message(msg, &packet)) != ERROR_SUCCESS) {
-                srs_error("decode packet from message payload failed. ret=%d", ret);
-                return ret;
+            if ((err = decode_message(msg, &packet)) != srs_success) {
+                return srs_error_wrap(err, "decode message");
             }
-            srs_verbose("decode packet from message payload success.");
             break;
         case RTMP_MSG_VideoMessage:
         case RTMP_MSG_AudioMessage:
             print_debug_info();
         default:
-            return ret;
+            return err;
     }
     
     srs_assert(packet);
@@ -1505,9 +1353,6 @@ int SrsProtocol::on_recv_message(SrsCommonMessage* msg)
                 // @remark, we ignore this message, for user noneed to care.
                 // but it's important for dev, for client/server will block if required
                 // ack msg not arrived.
-                srs_info("set ack window size to %d", pkt->ackowledgement_window_size);
-            } else {
-                srs_warn("ignored. set ack window size is %d", pkt->ackowledgement_window_size);
             }
             break;
         }
@@ -1518,24 +1363,17 @@ int SrsProtocol::on_recv_message(SrsCommonMessage* msg)
             // for some server, the actual chunk size can greater than the max value(65536),
             // so we just warning the invalid chunk size, and actually use it is ok,
             // @see: https://github.com/ossrs/srs/issues/160
-            if (pkt->chunk_size < SRS_CONSTS_RTMP_MIN_CHUNK_SIZE
-                || pkt->chunk_size > SRS_CONSTS_RTMP_MAX_CHUNK_SIZE)
-            {
+            if (pkt->chunk_size < SRS_CONSTS_RTMP_MIN_CHUNK_SIZE || pkt->chunk_size > SRS_CONSTS_RTMP_MAX_CHUNK_SIZE) {
                 srs_warn("accept chunk=%d, should in [%d, %d], please see #160",
                          pkt->chunk_size, SRS_CONSTS_RTMP_MIN_CHUNK_SIZE,  SRS_CONSTS_RTMP_MAX_CHUNK_SIZE);
             }
             
             // @see: https://github.com/ossrs/srs/issues/541
             if (pkt->chunk_size < SRS_CONSTS_RTMP_MIN_CHUNK_SIZE) {
-                ret = ERROR_RTMP_CHUNK_SIZE;
-                srs_error("chunk size should be %d+, value=%d. ret=%d",
-                          SRS_CONSTS_RTMP_MIN_CHUNK_SIZE, pkt->chunk_size, ret);
-                return ret;
+                return srs_error_new(ERROR_RTMP_CHUNK_SIZE, "chunk size should be %d+, value=%d", SRS_CONSTS_RTMP_MIN_CHUNK_SIZE, pkt->chunk_size);
             }
             
             in_chunk_size = pkt->chunk_size;
-            srs_info("in.chunk=%d", pkt->chunk_size);
-            
             break;
         }
         case RTMP_MSG_UserControlMessage: {
@@ -1544,12 +1382,10 @@ int SrsProtocol::on_recv_message(SrsCommonMessage* msg)
             
             if (pkt->event_type == SrcPCUCSetBufferLength) {
                 in_buffer_length = pkt->extra_data;
-                srs_info("buffer=%d, in.ack=%d, out.ack=%d, in.chunk=%d, out.chunk=%d", pkt->extra_data,
-                         in_ack_size.window, out_ack_size.window, in_chunk_size, out_chunk_size);
             }
             if (pkt->event_type == SrcPCUCPingRequest) {
-                if ((ret = response_ping_message(pkt->event_data)) != ERROR_SUCCESS) {
-                    return ret;
+                if ((err = response_ping_message(pkt->event_data)) != srs_success) {
+                    return srs_error_wrap(err, "response ping");
                 }
             }
             break;
@@ -1558,23 +1394,22 @@ int SrsProtocol::on_recv_message(SrsCommonMessage* msg)
             break;
     }
     
-    return ret;
+    return err;
 }
 
-int SrsProtocol::on_send_packet(SrsMessageHeader* mh, SrsPacket* packet)
+srs_error_t SrsProtocol::on_send_packet(SrsMessageHeader* mh, SrsPacket* packet)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // ignore raw bytes oriented RTMP message.
     if (packet == NULL) {
-        return ret;
+        return err;
     }
     
     switch (mh->message_type) {
         case RTMP_MSG_SetChunkSize: {
             SrsSetChunkSizePacket* pkt = dynamic_cast<SrsSetChunkSizePacket*>(packet);
             out_chunk_size = pkt->chunk_size;
-            srs_info("out.chunk=%d", pkt->chunk_size);
             break;
         }
         case RTMP_MSG_WindowAcknowledgementSize: {
@@ -1614,21 +1449,21 @@ int SrsProtocol::on_send_packet(SrsMessageHeader* mh, SrsPacket* packet)
             break;
     }
     
-    return ret;
+    return err;
 }
 
-int SrsProtocol::response_acknowledgement_message()
+srs_error_t SrsProtocol::response_acknowledgement_message()
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     if (in_ack_size.window <= 0) {
-        return ret;
+        return err;
     }
     
     // ignore when delta bytes not exceed half of window(ack size).
     uint32_t delta = (uint32_t)(skt->get_recv_bytes() - in_ack_size.nb_recv_bytes);
     if (delta < in_ack_size.window / 2) {
-        return ret;
+        return err;
     }
     in_ack_size.nb_recv_bytes = skt->get_recv_bytes();
     
@@ -1645,22 +1480,20 @@ int SrsProtocol::response_acknowledgement_message()
     // cache the message and use flush to send.
     if (!auto_response_when_recv) {
         manual_response_queue.push_back(pkt);
-        return ret;
+        return err;
     }
     
     // use underlayer api to send, donot flush again.
-    if ((ret = do_send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-        srs_error("send acknowledgement failed. ret=%d", ret);
-        return ret;
+    if ((err = do_send_and_free_packet(pkt, 0)) != srs_success) {
+        return srs_error_wrap(err, "send ack");
     }
-    srs_verbose("send acknowledgement success.");
     
-    return ret;
+    return err;
 }
 
-int SrsProtocol::response_ping_message(int32_t timestamp)
+srs_error_t SrsProtocol::response_ping_message(int32_t timestamp)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     srs_trace("get a ping request, response it. timestamp=%d", timestamp);
     
@@ -1672,17 +1505,15 @@ int SrsProtocol::response_ping_message(int32_t timestamp)
     // cache the message and use flush to send.
     if (!auto_response_when_recv) {
         manual_response_queue.push_back(pkt);
-        return ret;
+        return err;
     }
     
     // use underlayer api to send, donot flush again.
-    if ((ret = do_send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-        srs_error("send ping response failed. ret=%d", ret);
-        return ret;
+    if ((err = do_send_and_free_packet(pkt, 0)) != srs_success) {
+        return srs_error_wrap(err, "ping response");
     }
-    srs_verbose("send ping response success.");
     
-    return ret;
+    return err;
 }
 
 void SrsProtocol::print_debug_info()
@@ -1830,105 +1661,95 @@ SrsHandshakeBytes::~SrsHandshakeBytes()
     srs_freepa(c2);
 }
 
-int SrsHandshakeBytes::read_c0c1(ISrsProtocolReaderWriter* io)
+srs_error_t SrsHandshakeBytes::read_c0c1(ISrsProtocolReaderWriter* io)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     if (c0c1) {
-        return ret;
+        return err;
     }
     
     ssize_t nsize;
     
     c0c1 = new char[1537];
-    if ((ret = io->read_fully(c0c1, 1537, &nsize)) != ERROR_SUCCESS) {
-        srs_warn("read c0c1 failed. ret=%d", ret);
-        return ret;
+    if ((err = io->read_fully(c0c1, 1537, &nsize)) != srs_success) {
+        return srs_error_wrap(err, "read c0c1");
     }
-    srs_verbose("read c0c1 success.");
     
-    return ret;
+    return err;
 }
 
-int SrsHandshakeBytes::read_s0s1s2(ISrsProtocolReaderWriter* io)
+srs_error_t SrsHandshakeBytes::read_s0s1s2(ISrsProtocolReaderWriter* io)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     if (s0s1s2) {
-        return ret;
+        return err;
     }
     
     ssize_t nsize;
     
     s0s1s2 = new char[3073];
-    if ((ret = io->read_fully(s0s1s2, 3073, &nsize)) != ERROR_SUCCESS) {
-        srs_warn("read s0s1s2 failed. ret=%d", ret);
-        return ret;
+    if ((err = io->read_fully(s0s1s2, 3073, &nsize)) != srs_success) {
+        return srs_error_wrap(err, "read s0s1s2");
     }
-    srs_verbose("read s0s1s2 success.");
     
-    return ret;
+    return err;
 }
 
-int SrsHandshakeBytes::read_c2(ISrsProtocolReaderWriter* io)
+srs_error_t SrsHandshakeBytes::read_c2(ISrsProtocolReaderWriter* io)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     if (c2) {
-        return ret;
+        return err;
     }
     
     ssize_t nsize;
     
     c2 = new char[1536];
-    if ((ret = io->read_fully(c2, 1536, &nsize)) != ERROR_SUCCESS) {
-        srs_warn("read c2 failed. ret=%d", ret);
-        return ret;
+    if ((err = io->read_fully(c2, 1536, &nsize)) != srs_success) {
+        return srs_error_wrap(err, "read c2");
     }
-    srs_verbose("read c2 success.");
     
-    return ret;
+    return err;
 }
 
-int SrsHandshakeBytes::create_c0c1()
+srs_error_t SrsHandshakeBytes::create_c0c1()
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     if (c0c1) {
-        return ret;
+        return err;
     }
     
     c0c1 = new char[1537];
     srs_random_generate(c0c1, 1537);
     
     // plain text required.
-    SrsBuffer stream;
-    if ((ret = stream.initialize(c0c1, 9)) != ERROR_SUCCESS) {
-        return ret;
-    }
+    SrsBuffer stream(c0c1, 9);
+    
     stream.write_1bytes(0x03);
     stream.write_4bytes((int32_t)::time(NULL));
     stream.write_4bytes(0x00);
     
-    return ret;
+    return err;
 }
 
-int SrsHandshakeBytes::create_s0s1s2(const char* c1)
+srs_error_t SrsHandshakeBytes::create_s0s1s2(const char* c1)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     if (s0s1s2) {
-        return ret;
+        return err;
     }
     
     s0s1s2 = new char[3073];
     srs_random_generate(s0s1s2, 3073);
     
     // plain text required.
-    SrsBuffer stream;
-    if ((ret = stream.initialize(s0s1s2, 9)) != ERROR_SUCCESS) {
-        return ret;
-    }
+    SrsBuffer stream(s0s1s2, 9);
+    
     stream.write_1bytes(0x03);
     stream.write_4bytes((int32_t)::time(NULL));
     // s1 time2 copy from c1
@@ -1942,32 +1763,30 @@ int SrsHandshakeBytes::create_s0s1s2(const char* c1)
         memcpy(s0s1s2 + 1537, c1, 1536);
     }
     
-    return ret;
+    return err;
 }
 
-int SrsHandshakeBytes::create_c2()
+srs_error_t SrsHandshakeBytes::create_c2()
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     if (c2) {
-        return ret;
+        return err;
     }
     
     c2 = new char[1536];
     srs_random_generate(c2, 1536);
     
     // time
-    SrsBuffer stream;
-    if ((ret = stream.initialize(c2, 8)) != ERROR_SUCCESS) {
-        return ret;
-    }
+    SrsBuffer stream(c2, 8);
+    
     stream.write_4bytes((int32_t)::time(NULL));
     // c2 time2 copy from s1
     if (s0s1s2) {
         stream.write_bytes(s0s1s2 + 1, 4);
     }
     
-    return ret;
+    return err;
 }
 
 SrsServerInfo::SrsServerInfo()
@@ -2009,34 +1828,34 @@ int64_t SrsRtmpClient::get_send_bytes()
     return protocol->get_send_bytes();
 }
 
-int SrsRtmpClient::recv_message(SrsCommonMessage** pmsg)
+srs_error_t SrsRtmpClient::recv_message(SrsCommonMessage** pmsg)
 {
     return protocol->recv_message(pmsg);
 }
 
-int SrsRtmpClient::decode_message(SrsCommonMessage* msg, SrsPacket** ppacket)
+srs_error_t SrsRtmpClient::decode_message(SrsCommonMessage* msg, SrsPacket** ppacket)
 {
     return protocol->decode_message(msg, ppacket);
 }
 
-int SrsRtmpClient::send_and_free_message(SrsSharedPtrMessage* msg, int stream_id)
+srs_error_t SrsRtmpClient::send_and_free_message(SrsSharedPtrMessage* msg, int stream_id)
 {
     return protocol->send_and_free_message(msg, stream_id);
 }
 
-int SrsRtmpClient::send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs, int stream_id)
+srs_error_t SrsRtmpClient::send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs, int stream_id)
 {
     return protocol->send_and_free_messages(msgs, nb_msgs, stream_id);
 }
 
-int SrsRtmpClient::send_and_free_packet(SrsPacket* packet, int stream_id)
+srs_error_t SrsRtmpClient::send_and_free_packet(SrsPacket* packet, int stream_id)
 {
     return protocol->send_and_free_packet(packet, stream_id);
 }
 
-int SrsRtmpClient::handshake()
+srs_error_t SrsRtmpClient::handshake()
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     srs_assert(hs_bytes);
     
@@ -2045,60 +1864,62 @@ int SrsRtmpClient::handshake()
     SrsComplexHandshake* complex_hs = new SrsComplexHandshake();
     SrsAutoFree(SrsComplexHandshake, complex_hs);
     
-    if ((ret = complex_hs->handshake_with_server(hs_bytes, io)) != ERROR_SUCCESS) {
-        if (ret == ERROR_RTMP_TRY_SIMPLE_HS) {
+    if ((err = complex_hs->handshake_with_server(hs_bytes, io)) != srs_success) {
+        if (srs_error_code(err) == ERROR_RTMP_TRY_SIMPLE_HS) {
+            srs_freep(err);
+            
             // always alloc object at heap.
             // @see https://github.com/ossrs/srs/issues/509
             SrsSimpleHandshake* simple_hs = new SrsSimpleHandshake();
             SrsAutoFree(SrsSimpleHandshake, simple_hs);
             
-            if ((ret = simple_hs->handshake_with_server(hs_bytes, io)) != ERROR_SUCCESS) {
-                return ret;
+            if ((err = simple_hs->handshake_with_server(hs_bytes, io)) != srs_success) {
+                return srs_error_wrap(err, "simple handshake");
             }
         }
-        return ret;
+        return srs_error_wrap(err, "complex handshake");
     }
     
     srs_freep(hs_bytes);
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpClient::simple_handshake()
+srs_error_t SrsRtmpClient::simple_handshake()
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     srs_assert(hs_bytes);
     
     SrsSimpleHandshake simple_hs;
-    if ((ret = simple_hs.handshake_with_server(hs_bytes, io)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = simple_hs.handshake_with_server(hs_bytes, io)) != srs_success) {
+        return srs_error_wrap(err, "simple handshake");
     }
     
     srs_freep(hs_bytes);
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpClient::complex_handshake()
+srs_error_t SrsRtmpClient::complex_handshake()
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     srs_assert(hs_bytes);
     
     SrsComplexHandshake complex_hs;
-    if ((ret = complex_hs.handshake_with_server(hs_bytes, io)) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = complex_hs.handshake_with_server(hs_bytes, io)) != srs_success) {
+        return srs_error_wrap(err, "complex handshake");
     }
     
     srs_freep(hs_bytes);
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpClient::connect_app(string app, string tcUrl, SrsRequest* r, bool dsu, SrsServerInfo* si)
+srs_error_t SrsRtmpClient::connect_app(string app, string tcUrl, SrsRequest* r, bool dsu, SrsServerInfo* si)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // Connect(vhost, app)
     if (true) {
@@ -2135,8 +1956,8 @@ int SrsRtmpClient::connect_app(string app, string tcUrl, SrsRequest* r, bool dsu
             pkt->args = r->args->copy()->to_object();
         }
         
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send packet");
         }
     }
     
@@ -2144,17 +1965,16 @@ int SrsRtmpClient::connect_app(string app, string tcUrl, SrsRequest* r, bool dsu
     if (true) {
         SrsSetWindowAckSizePacket* pkt = new SrsSetWindowAckSizePacket();
         pkt->ackowledgement_window_size = 2500000;
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send packet");
         }
     }
     
     // expect connect _result
     SrsCommonMessage* msg = NULL;
     SrsConnectAppResPacket* pkt = NULL;
-    if ((ret = expect_message<SrsConnectAppResPacket>(&msg, &pkt)) != ERROR_SUCCESS) {
-        srs_error("expect connect app response message failed. ret=%d", ret);
-        return ret;
+    if ((err = expect_message<SrsConnectAppResPacket>(&msg, &pkt)) != srs_success) {
+        return srs_error_wrap(err, "expect connect app response");
     }
     SrsAutoFree(SrsCommonMessage, msg);
     SrsAutoFree(SrsConnectAppResPacket, pkt);
@@ -2201,18 +2021,18 @@ int SrsRtmpClient::connect_app(string app, string tcUrl, SrsRequest* r, bool dsu
         srs_trace("connected, dsu=%d", dsu);
     }
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpClient::create_stream(int& stream_id)
+srs_error_t SrsRtmpClient::create_stream(int& stream_id)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // CreateStream
     if (true) {
         SrsCreateStreamPacket* pkt = new SrsCreateStreamPacket();
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send packet");
         }
     }
     
@@ -2220,33 +2040,28 @@ int SrsRtmpClient::create_stream(int& stream_id)
     if (true) {
         SrsCommonMessage* msg = NULL;
         SrsCreateStreamResPacket* pkt = NULL;
-        if ((ret = expect_message<SrsCreateStreamResPacket>(&msg, &pkt)) != ERROR_SUCCESS) {
-            srs_error("expect create stream response message failed. ret=%d", ret);
-            return ret;
+        if ((err = expect_message<SrsCreateStreamResPacket>(&msg, &pkt)) != srs_success) {
+            return srs_error_wrap(err, "expect create stream response");
         }
         SrsAutoFree(SrsCommonMessage, msg);
         SrsAutoFree(SrsCreateStreamResPacket, pkt);
-        srs_info("get create stream response message");
         
         stream_id = (int)pkt->stream_id;
     }
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpClient::play(string stream, int stream_id)
+srs_error_t SrsRtmpClient::play(string stream, int stream_id)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // Play(stream)
     if (true) {
         SrsPlayPacket* pkt = new SrsPlayPacket();
         pkt->stream_name = stream;
-        if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-            srs_error("send play stream failed. "
-                      "stream=%s, stream_id=%d, ret=%d",
-                      stream.c_str(), stream_id, ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+            return srs_error_wrap(err, "send play stream failed. stream=%s, stream_id=%d", stream.c_str(), stream_id);
         }
     }
     
@@ -2259,11 +2074,8 @@ int SrsRtmpClient::play(string stream, int stream_id)
         pkt->event_data = stream_id;
         pkt->extra_data = buffer_length_ms;
         
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            srs_error("send set buffer length failed. "
-                      "stream=%s, stream_id=%d, bufferLength=%d, ret=%d",
-                      stream.c_str(), stream_id, buffer_length_ms, ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send set buffer length failed. stream=%s, stream_id=%d, bufferLength=%d", stream.c_str(), stream_id, buffer_length_ms);
         }
     }
     
@@ -2271,30 +2083,24 @@ int SrsRtmpClient::play(string stream, int stream_id)
     if (true) {
         SrsSetChunkSizePacket* pkt = new SrsSetChunkSizePacket();
         pkt->chunk_size = SRS_CONSTS_RTMP_SRS_CHUNK_SIZE;
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            srs_error("send set chunk size failed. "
-                      "stream=%s, chunk_size=%d, ret=%d",
-                      stream.c_str(), SRS_CONSTS_RTMP_SRS_CHUNK_SIZE, ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send set chunk size failed. stream=%s, chunk_size=%d", stream.c_str(), SRS_CONSTS_RTMP_SRS_CHUNK_SIZE);
         }
     }
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpClient::publish(string stream, int stream_id)
+srs_error_t SrsRtmpClient::publish(string stream, int stream_id)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // SetChunkSize
     if (true) {
         SrsSetChunkSizePacket* pkt = new SrsSetChunkSizePacket();
         pkt->chunk_size = SRS_CONSTS_RTMP_SRS_CHUNK_SIZE;
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            srs_error("send set chunk size failed. "
-                      "stream=%s, chunk_size=%d, ret=%d",
-                      stream.c_str(), SRS_CONSTS_RTMP_SRS_CHUNK_SIZE, ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send set chunk size failed. stream=%s, chunk_size=%d", stream.c_str(), SRS_CONSTS_RTMP_SRS_CHUNK_SIZE);
         }
     }
     
@@ -2302,40 +2108,33 @@ int SrsRtmpClient::publish(string stream, int stream_id)
     if (true) {
         SrsPublishPacket* pkt = new SrsPublishPacket();
         pkt->stream_name = stream;
-        if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-            srs_error("send publish message failed. "
-                      "stream=%s, stream_id=%d, ret=%d",
-                      stream.c_str(), stream_id, ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+            return srs_error_wrap(err, "send publish message failed. stream=%s, stream_id=%d", stream.c_str(), stream_id);
         }
     }
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpClient::fmle_publish(string stream, int& stream_id)
+srs_error_t SrsRtmpClient::fmle_publish(string stream, int& stream_id)
 {
     stream_id = 0;
     
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // SrsFMLEStartPacket
     if (true) {
         SrsFMLEStartPacket* pkt = SrsFMLEStartPacket::create_release_stream(stream);
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            srs_error("send FMLE publish "
-                      "release stream failed. stream=%s, ret=%d", stream.c_str(), ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send FMLE publish release stream failed. stream=%s", stream.c_str());
         }
     }
     
     // FCPublish
     if (true) {
         SrsFMLEStartPacket* pkt = SrsFMLEStartPacket::create_FC_publish(stream);
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            srs_error("send FMLE publish "
-                      "FCPublish failed. stream=%s, ret=%d", stream.c_str(), ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send FMLE publish FCPublish failed. stream=%s", stream.c_str());
         }
     }
     
@@ -2343,10 +2142,8 @@ int SrsRtmpClient::fmle_publish(string stream, int& stream_id)
     if (true) {
         SrsCreateStreamPacket* pkt = new SrsCreateStreamPacket();
         pkt->transaction_id = 4;
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            srs_error("send FMLE publish "
-                      "createStream failed. stream=%s, ret=%d", stream.c_str(), ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send FMLE publish createStream failed. stream=%s", stream.c_str());
         }
     }
     
@@ -2354,13 +2151,11 @@ int SrsRtmpClient::fmle_publish(string stream, int& stream_id)
     if (true) {
         SrsCommonMessage* msg = NULL;
         SrsCreateStreamResPacket* pkt = NULL;
-        if ((ret = expect_message<SrsCreateStreamResPacket>(&msg, &pkt)) != ERROR_SUCCESS) {
-            srs_error("expect create stream response message failed. ret=%d", ret);
-            return ret;
+        if ((err = expect_message<SrsCreateStreamResPacket>(&msg, &pkt)) != srs_success) {
+            return srs_error_wrap(err, "expect create stream response message failed");
         }
         SrsAutoFree(SrsCommonMessage, msg);
         SrsAutoFree(SrsCreateStreamResPacket, pkt);
-        srs_info("get create stream response message");
         
         stream_id = (int)pkt->stream_id;
     }
@@ -2369,14 +2164,12 @@ int SrsRtmpClient::fmle_publish(string stream, int& stream_id)
     if (true) {
         SrsPublishPacket* pkt = new SrsPublishPacket();
         pkt->stream_name = stream;
-        if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-            srs_error("send FMLE publish publish failed. "
-                      "stream=%s, stream_id=%d, ret=%d", stream.c_str(), stream_id, ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+            return srs_error_wrap(err, "send FMLE publish publish failed. stream=%s, stream_id=%d", stream.c_str(), stream_id);
         }
     }
     
-    return ret;
+    return err;
 }
 
 SrsRtmpServer::SrsRtmpServer(ISrsProtocolReaderWriter* skt)
@@ -2439,73 +2232,71 @@ int64_t SrsRtmpServer::get_send_bytes()
     return protocol->get_send_bytes();
 }
 
-int SrsRtmpServer::recv_message(SrsCommonMessage** pmsg)
+srs_error_t SrsRtmpServer::recv_message(SrsCommonMessage** pmsg)
 {
     return protocol->recv_message(pmsg);
 }
 
-int SrsRtmpServer::decode_message(SrsCommonMessage* msg, SrsPacket** ppacket)
+srs_error_t SrsRtmpServer::decode_message(SrsCommonMessage* msg, SrsPacket** ppacket)
 {
     return protocol->decode_message(msg, ppacket);
 }
 
-int SrsRtmpServer::send_and_free_message(SrsSharedPtrMessage* msg, int stream_id)
+srs_error_t SrsRtmpServer::send_and_free_message(SrsSharedPtrMessage* msg, int stream_id)
 {
     return protocol->send_and_free_message(msg, stream_id);
 }
 
-int SrsRtmpServer::send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs, int stream_id)
+srs_error_t SrsRtmpServer::send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs, int stream_id)
 {
     return protocol->send_and_free_messages(msgs, nb_msgs, stream_id);
 }
 
-int SrsRtmpServer::send_and_free_packet(SrsPacket* packet, int stream_id)
+srs_error_t SrsRtmpServer::send_and_free_packet(SrsPacket* packet, int stream_id)
 {
     return protocol->send_and_free_packet(packet, stream_id);
 }
 
-int SrsRtmpServer::handshake()
+srs_error_t SrsRtmpServer::handshake()
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     srs_assert(hs_bytes);
     
     SrsComplexHandshake complex_hs;
-    if ((ret = complex_hs.handshake_with_client(hs_bytes, io)) != ERROR_SUCCESS) {
-        if (ret == ERROR_RTMP_TRY_SIMPLE_HS) {
+    if ((err = complex_hs.handshake_with_client(hs_bytes, io)) != srs_success) {
+        if (srs_error_code(err) == ERROR_RTMP_TRY_SIMPLE_HS) {
+            srs_freep(err);
+            
             SrsSimpleHandshake simple_hs;
-            if ((ret = simple_hs.handshake_with_client(hs_bytes, io)) != ERROR_SUCCESS) {
-                return ret;
+            if ((err = simple_hs.handshake_with_client(hs_bytes, io)) != srs_success) {
+                return srs_error_wrap(err, "simple handshake");
             }
         }
-        return ret;
+        return srs_error_wrap(err, "complex handshake");
     }
     
     srs_freep(hs_bytes);
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::connect_app(SrsRequest* req)
+srs_error_t SrsRtmpServer::connect_app(SrsRequest* req)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     SrsCommonMessage* msg = NULL;
     SrsConnectAppPacket* pkt = NULL;
-    if ((ret = expect_message<SrsConnectAppPacket>(&msg, &pkt)) != ERROR_SUCCESS) {
-        srs_error("expect connect app message failed. ret=%d", ret);
-        return ret;
+    if ((err = expect_message<SrsConnectAppPacket>(&msg, &pkt)) != srs_success) {
+        return srs_error_wrap(err, "expect connect app response");
     }
     SrsAutoFree(SrsCommonMessage, msg);
     SrsAutoFree(SrsConnectAppPacket, pkt);
-    srs_info("get connect app message");
     
     SrsAmf0Any* prop = NULL;
     
     if ((prop = pkt->command_object->ensure_property_string("tcUrl")) == NULL) {
-        ret = ERROR_RTMP_REQ_CONNECT;
-        srs_error("invalid request, must specifies the tcUrl. ret=%d", ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_REQ_CONNECT, "invalid request without tcUrl");
     }
     req->tcUrl = prop->to_str();
     
@@ -2524,59 +2315,49 @@ int SrsRtmpServer::connect_app(SrsRequest* req)
     if (pkt->args) {
         srs_freep(req->args);
         req->args = pkt->args->copy()->to_object();
-        srs_info("copy edge traverse to origin auth args.");
     }
     
-    srs_info("get connect app message params success.");
-    
-    srs_discovery_tc_url(req->tcUrl,
-                         req->schema, req->host, req->vhost, req->app, req->port,
-                         req->param);
+    srs_discovery_tc_url(req->tcUrl, req->schema, req->host, req->vhost, req->app, req->port, req->param);
     req->strip();
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::set_window_ack_size(int ack_size)
+srs_error_t SrsRtmpServer::set_window_ack_size(int ack_size)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     SrsSetWindowAckSizePacket* pkt = new SrsSetWindowAckSizePacket();
     pkt->ackowledgement_window_size = ack_size;
-    if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-        srs_error("send ack size message failed. ret=%d", ret);
-        return ret;
+    if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+        return srs_error_wrap(err, "send ack");
     }
-    srs_info("send ack size message success. ack_size=%d", ack_size);
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::set_in_window_ack_size(int ack_size)
+srs_error_t SrsRtmpServer::set_in_window_ack_size(int ack_size)
 {
     return protocol->set_in_window_ack_size(ack_size);
 }
 
-int SrsRtmpServer::set_peer_bandwidth(int bandwidth, int type)
+srs_error_t SrsRtmpServer::set_peer_bandwidth(int bandwidth, int type)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     SrsSetPeerBandwidthPacket* pkt = new SrsSetPeerBandwidthPacket();
     pkt->bandwidth = bandwidth;
     pkt->type = type;
-    if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-        srs_error("send set bandwidth message failed. ret=%d", ret);
-        return ret;
+    if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+        return srs_error_wrap(err, "send set peer bandwidth");
     }
-    srs_info("send set bandwidth message "
-             "success. bandwidth=%d, type=%d", bandwidth, type);
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::response_connect_app(SrsRequest *req, const char* server_ip)
+srs_error_t SrsRtmpServer::response_connect_app(SrsRequest *req, const char* server_ip)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     SrsConnectAppResPacket* pkt = new SrsConnectAppResPacket();
     
@@ -2611,19 +2392,17 @@ int SrsRtmpServer::response_connect_app(SrsRequest *req, const char* server_ip)
     data->set("srs_pid", SrsAmf0Any::number(getpid()));
     data->set("srs_id", SrsAmf0Any::number(_srs_context->get_id()));
     
-    if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-        srs_error("send connect app response message failed. ret=%d", ret);
-        return ret;
+    if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+        return srs_error_wrap(err, "send connect app response");
     }
-    srs_info("send connect app response message success.");
     
-    return ret;
+    return err;
 }
 
 #define SRS_RTMP_REDIRECT_TMMS 3000
-int SrsRtmpServer::redirect(SrsRequest* r, string host, int port, bool& accepted)
+srs_error_t SrsRtmpServer::redirect(SrsRequest* r, string host, int port, bool& accepted)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     if (true) {
         string url = srs_generate_rtmp_url(host, port, r->vhost, r->app, "");
@@ -2639,11 +2418,9 @@ int SrsRtmpServer::redirect(SrsRequest* r, string host, int port, bool& accepted
         pkt->data->set(StatusDescription, SrsAmf0Any::str("RTMP 302 Redirect"));
         pkt->data->set("ex", ex);
         
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            srs_error("send redirect/rejected message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send redirect/reject");
         }
-        srs_info("send redirect/rejected message success.");
     }
     
     // client must response a call message.
@@ -2652,9 +2429,10 @@ int SrsRtmpServer::redirect(SrsRequest* r, string host, int port, bool& accepted
     if (true) {
         SrsCommonMessage* msg = NULL;
         SrsCallPacket* pkt = NULL;
-        if ((ret = expect_message<SrsCallPacket>(&msg, &pkt)) != ERROR_SUCCESS) {
+        if ((err = expect_message<SrsCallPacket>(&msg, &pkt)) != srs_success) {
+            srs_freep(err);
             // ignore any error of redirect response.
-            return ERROR_SUCCESS;
+            return srs_success;
         }
         SrsAutoFree(SrsCommonMessage, msg);
         SrsAutoFree(SrsCallPacket, pkt);
@@ -2662,59 +2440,51 @@ int SrsRtmpServer::redirect(SrsRequest* r, string host, int port, bool& accepted
         string message;
         if (pkt->arguments && pkt->arguments->is_string()) {
             message = pkt->arguments->to_str();
-            srs_info("confirm redirected to %s", message.c_str());
             accepted = true;
         }
-        srs_info("get redirect response message");
     }
     
-    return ret;
+    return err;
 }
 
 void SrsRtmpServer::response_connect_reject(SrsRequest* /*req*/, const char* desc)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     SrsOnStatusCallPacket* pkt = new SrsOnStatusCallPacket();
     pkt->data->set(StatusLevel, SrsAmf0Any::str(StatusLevelError));
     pkt->data->set(StatusCode, SrsAmf0Any::str(StatusCodeConnectRejected));
     pkt->data->set(StatusDescription, SrsAmf0Any::str(desc));
     
-    if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-        srs_error("send connect app response rejected message failed. ret=%d", ret);
-        return;
+    if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+        srs_warn("send reject response err %s", srs_error_desc(err).c_str());
+        srs_freep(err);
     }
-    srs_info("send connect app response rejected message success.");
     
     return;
 }
 
-int SrsRtmpServer::on_bw_done()
+srs_error_t SrsRtmpServer::on_bw_done()
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     SrsOnBWDonePacket* pkt = new SrsOnBWDonePacket();
-    if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-        srs_error("send onBWDone message failed. ret=%d", ret);
-        return ret;
+    if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+        return srs_error_wrap(err, "send onBWDone");
     }
-    srs_info("send onBWDone message success.");
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::identify_client(int stream_id, SrsRtmpConnType& type, string& stream_name, double& duration)
+srs_error_t SrsRtmpServer::identify_client(int stream_id, SrsRtmpConnType& type, string& stream_name, double& duration)
 {
     type = SrsRtmpConnUnknown;
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     while (true) {
         SrsCommonMessage* msg = NULL;
-        if ((ret = protocol->recv_message(&msg)) != ERROR_SUCCESS) {
-            if (!srs_is_client_gracefully_close(ret)) {
-                srs_error("recv identify client message failed. ret=%d", ret);
-            }
-            return ret;
+        if ((err = protocol->recv_message(&msg)) != srs_success) {
+            return srs_error_wrap(err, "recv identify message");
         }
         
         SrsAutoFree(SrsCommonMessage, msg);
@@ -2725,29 +2495,24 @@ int SrsRtmpServer::identify_client(int stream_id, SrsRtmpConnType& type, string&
         }
         
         if (!h.is_amf0_command() && !h.is_amf3_command()) {
-            srs_trace("identify ignore messages except "
-                      "AMF0/AMF3 command message. type=%#x", h.message_type);
+            srs_trace("ignore message type=%#x", h.message_type);
             continue;
         }
         
         SrsPacket* pkt = NULL;
-        if ((ret = protocol->decode_message(msg, &pkt)) != ERROR_SUCCESS) {
-            srs_error("identify decode message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->decode_message(msg, &pkt)) != srs_success) {
+            return srs_error_wrap(err, "decode identify");
         }
         
         SrsAutoFree(SrsPacket, pkt);
         
         if (dynamic_cast<SrsCreateStreamPacket*>(pkt)) {
-            srs_info("identify client by create stream, play or flash publish.");
             return identify_create_stream_client(dynamic_cast<SrsCreateStreamPacket*>(pkt), stream_id, type, stream_name, duration);
         }
         if (dynamic_cast<SrsFMLEStartPacket*>(pkt)) {
-            srs_info("identify client by releaseStream, fmle publish.");
             return identify_fmle_publish_client(dynamic_cast<SrsFMLEStartPacket*>(pkt), type, stream_name);
         }
         if (dynamic_cast<SrsPlayPacket*>(pkt)) {
-            srs_info("level0 identify client by play.");
             return identify_play_client(dynamic_cast<SrsPlayPacket*>(pkt), type, stream_name, duration);
         }
         // call msg,
@@ -2759,18 +2524,14 @@ int SrsRtmpServer::identify_client(int stream_id, SrsRtmpConnType& type, string&
             SrsCallResPacket* res = new SrsCallResPacket(call->transaction_id);
             res->command_object = SrsAmf0Any::null();
             res->response = SrsAmf0Any::null();
-            if ((ret = protocol->send_and_free_packet(res, 0)) != ERROR_SUCCESS) {
-                if (!srs_is_system_control_error(ret) && !srs_is_client_gracefully_close(ret)) {
-                    srs_warn("response call failed. ret=%d", ret);
-                }
-                return ret;
+            if ((err = protocol->send_and_free_packet(res, 0)) != srs_success) {
+                return srs_error_wrap(err, "response call");
             }
             
             // For encoder of Haivision, it always send a _checkbw call message.
             // @remark the next message is createStream, so we continue to identify it.
             // @see https://github.com/ossrs/srs/issues/844
             if (call->command_name == "_checkbw") {
-                srs_info("Haivision encoder identified.");
                 continue;
             }
             continue;
@@ -2779,38 +2540,34 @@ int SrsRtmpServer::identify_client(int stream_id, SrsRtmpConnType& type, string&
         srs_trace("ignore AMF0/AMF3 command message.");
     }
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::set_chunk_size(int chunk_size)
+srs_error_t SrsRtmpServer::set_chunk_size(int chunk_size)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     SrsSetChunkSizePacket* pkt = new SrsSetChunkSizePacket();
     pkt->chunk_size = chunk_size;
-    if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-        srs_error("send set chunk size message failed. ret=%d", ret);
-        return ret;
+    if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+        return srs_error_wrap(err, "send set chunk size");
     }
-    srs_info("send set chunk size message success. chunk_size=%d", chunk_size);
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::start_play(int stream_id)
+srs_error_t SrsRtmpServer::start_play(int stream_id)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // StreamBegin
     if (true) {
         SrsUserControlPacket* pkt = new SrsUserControlPacket();
         pkt->event_type = SrcPCUCStreamBegin;
         pkt->event_data = stream_id;
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            srs_error("send PCUC(StreamBegin) message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send StreamBegin");
         }
-        srs_info("send PCUC(StreamBegin) message success.");
     }
     
     // onStatus(NetStream.Play.Reset)
@@ -2823,11 +2580,9 @@ int SrsRtmpServer::start_play(int stream_id)
         pkt->data->set(StatusDetails, SrsAmf0Any::str("stream"));
         pkt->data->set(StatusClientId, SrsAmf0Any::str(RTMP_SIG_CLIENT_ID));
         
-        if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-            srs_error("send onStatus(NetStream.Play.Reset) message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+            return srs_error_wrap(err, "send NetStream.Play.Reset");
         }
-        srs_info("send onStatus(NetStream.Play.Reset) message success.");
     }
     
     // onStatus(NetStream.Play.Start)
@@ -2840,11 +2595,9 @@ int SrsRtmpServer::start_play(int stream_id)
         pkt->data->set(StatusDetails, SrsAmf0Any::str("stream"));
         pkt->data->set(StatusClientId, SrsAmf0Any::str(RTMP_SIG_CLIENT_ID));
         
-        if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-            srs_error("send onStatus(NetStream.Play.Start) message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+            return srs_error_wrap(err, "send NetStream.Play.Start");
         }
-        srs_info("send onStatus(NetStream.Play.Start) message success.");
     }
     
     // |RtmpSampleAccess(false, false)
@@ -2856,32 +2609,26 @@ int SrsRtmpServer::start_play(int stream_id)
         pkt->audio_sample_access = true;
         pkt->video_sample_access = true;
         
-        if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-            srs_error("send |RtmpSampleAccess(false, false) message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+            return srs_error_wrap(err, "send |RtmpSampleAccess true");
         }
-        srs_info("send |RtmpSampleAccess(false, false) message success.");
     }
     
     // onStatus(NetStream.Data.Start)
     if (true) {
         SrsOnStatusDataPacket* pkt = new SrsOnStatusDataPacket();
         pkt->data->set(StatusCode, SrsAmf0Any::str(StatusCodeDataStart));
-        if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-            srs_error("send onStatus(NetStream.Data.Start) message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+            return srs_error_wrap(err, "send NetStream.Data.Start");
         }
-        srs_info("send onStatus(NetStream.Data.Start) message success.");
     }
     
-    srs_info("start play success.");
-    
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::on_play_client_pause(int stream_id, bool is_pause)
+srs_error_t SrsRtmpServer::on_play_client_pause(int stream_id, bool is_pause)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     if (is_pause) {
         // onStatus(NetStream.Pause.Notify)
@@ -2892,11 +2639,9 @@ int SrsRtmpServer::on_play_client_pause(int stream_id, bool is_pause)
             pkt->data->set(StatusCode, SrsAmf0Any::str(StatusCodeStreamPause));
             pkt->data->set(StatusDescription, SrsAmf0Any::str("Paused stream."));
             
-            if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-                srs_error("send onStatus(NetStream.Pause.Notify) message failed. ret=%d", ret);
-                return ret;
+            if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+                return srs_error_wrap(err, "send NetStream.Pause.Notify");
             }
-            srs_info("send onStatus(NetStream.Pause.Notify) message success.");
         }
         // StreamEOF
         if (true) {
@@ -2905,11 +2650,9 @@ int SrsRtmpServer::on_play_client_pause(int stream_id, bool is_pause)
             pkt->event_type = SrcPCUCStreamEOF;
             pkt->event_data = stream_id;
             
-            if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-                srs_error("send PCUC(StreamEOF) message failed. ret=%d", ret);
-                return ret;
+            if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+                return srs_error_wrap(err, "send StreamEOF");
             }
-            srs_info("send PCUC(StreamEOF) message success.");
         }
     } else {
         // onStatus(NetStream.Unpause.Notify)
@@ -2920,11 +2663,9 @@ int SrsRtmpServer::on_play_client_pause(int stream_id, bool is_pause)
             pkt->data->set(StatusCode, SrsAmf0Any::str(StatusCodeStreamUnpause));
             pkt->data->set(StatusDescription, SrsAmf0Any::str("Unpaused stream."));
             
-            if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-                srs_error("send onStatus(NetStream.Unpause.Notify) message failed. ret=%d", ret);
-                return ret;
+            if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+                return srs_error_wrap(err, "send NetStream.Unpause.Notify");
             }
-            srs_info("send onStatus(NetStream.Unpause.Notify) message success.");
         }
         // StreanBegin
         if (true) {
@@ -2933,31 +2674,27 @@ int SrsRtmpServer::on_play_client_pause(int stream_id, bool is_pause)
             pkt->event_type = SrcPCUCStreamBegin;
             pkt->event_data = stream_id;
             
-            if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-                srs_error("send PCUC(StreanBegin) message failed. ret=%d", ret);
-                return ret;
+            if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+                return srs_error_wrap(err, "send StreamBegin");
             }
-            srs_info("send PCUC(StreanBegin) message success.");
         }
     }
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::start_fmle_publish(int stream_id)
+srs_error_t SrsRtmpServer::start_fmle_publish(int stream_id)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // FCPublish
     double fc_publish_tid = 0;
     if (true) {
         SrsCommonMessage* msg = NULL;
         SrsFMLEStartPacket* pkt = NULL;
-        if ((ret = expect_message<SrsFMLEStartPacket>(&msg, &pkt)) != ERROR_SUCCESS) {
-            srs_error("recv FCPublish message failed. ret=%d", ret);
-            return ret;
+        if ((err = expect_message<SrsFMLEStartPacket>(&msg, &pkt)) != srs_success) {
+            return srs_error_wrap(err, "recv FCPublish");
         }
-        srs_info("recv FCPublish request message success.");
         
         SrsAutoFree(SrsCommonMessage, msg);
         SrsAutoFree(SrsFMLEStartPacket, pkt);
@@ -2967,11 +2704,9 @@ int SrsRtmpServer::start_fmle_publish(int stream_id)
     // FCPublish response
     if (true) {
         SrsFMLEStartResPacket* pkt = new SrsFMLEStartResPacket(fc_publish_tid);
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            srs_error("send FCPublish response message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send FCPublish response");
         }
-        srs_info("send FCPublish response message success.");
     }
     
     // createStream
@@ -2979,11 +2714,9 @@ int SrsRtmpServer::start_fmle_publish(int stream_id)
     if (true) {
         SrsCommonMessage* msg = NULL;
         SrsCreateStreamPacket* pkt = NULL;
-        if ((ret = expect_message<SrsCreateStreamPacket>(&msg, &pkt)) != ERROR_SUCCESS) {
-            srs_error("recv createStream message failed. ret=%d", ret);
-            return ret;
+        if ((err = expect_message<SrsCreateStreamPacket>(&msg, &pkt)) != srs_success) {
+            return srs_error_wrap(err, "recv createStream");
         }
-        srs_info("recv createStream request message success.");
         
         SrsAutoFree(SrsCommonMessage, msg);
         SrsAutoFree(SrsCreateStreamPacket, pkt);
@@ -2993,22 +2726,18 @@ int SrsRtmpServer::start_fmle_publish(int stream_id)
     // createStream response
     if (true) {
         SrsCreateStreamResPacket* pkt = new SrsCreateStreamResPacket(create_stream_tid, stream_id);
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            srs_error("send createStream response message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send createStream response");
         }
-        srs_info("send createStream response message success.");
     }
     
     // publish
     if (true) {
         SrsCommonMessage* msg = NULL;
         SrsPublishPacket* pkt = NULL;
-        if ((ret = expect_message<SrsPublishPacket>(&msg, &pkt)) != ERROR_SUCCESS) {
-            srs_error("recv publish message failed. ret=%d", ret);
-            return ret;
+        if ((err = expect_message<SrsPublishPacket>(&msg, &pkt)) != srs_success) {
+            return srs_error_wrap(err, "recv publish");
         }
-        srs_info("recv publish request message success.");
         
         SrsAutoFree(SrsCommonMessage, msg);
         SrsAutoFree(SrsPublishPacket, pkt);
@@ -3021,11 +2750,9 @@ int SrsRtmpServer::start_fmle_publish(int stream_id)
         pkt->data->set(StatusCode, SrsAmf0Any::str(StatusCodePublishStart));
         pkt->data->set(StatusDescription, SrsAmf0Any::str("Started publishing stream."));
         
-        if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-            srs_error("send onFCPublish(NetStream.Publish.Start) message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+            return srs_error_wrap(err, "send NetStream.Publish.Start");
         }
-        srs_info("send onFCPublish(NetStream.Publish.Start) message success.");
     }
     // publish response onStatus(NetStream.Publish.Start)
     if (true) {
@@ -3036,31 +2763,25 @@ int SrsRtmpServer::start_fmle_publish(int stream_id)
         pkt->data->set(StatusDescription, SrsAmf0Any::str("Started publishing stream."));
         pkt->data->set(StatusClientId, SrsAmf0Any::str(RTMP_SIG_CLIENT_ID));
         
-        if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-            srs_error("send onStatus(NetStream.Publish.Start) message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+            return srs_error_wrap(err, "send NetStream.Publish.Start");
         }
-        srs_info("send onStatus(NetStream.Publish.Start) message success.");
     }
     
-    srs_info("FMLE publish success.");
-    
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::start_haivision_publish(int stream_id)
+srs_error_t SrsRtmpServer::start_haivision_publish(int stream_id)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // publish
     if (true) {
         SrsCommonMessage* msg = NULL;
         SrsPublishPacket* pkt = NULL;
-        if ((ret = expect_message<SrsPublishPacket>(&msg, &pkt)) != ERROR_SUCCESS) {
-            srs_error("recv publish message failed. ret=%d", ret);
-            return ret;
+        if ((err = expect_message<SrsPublishPacket>(&msg, &pkt)) != srs_success) {
+            return srs_error_wrap(err, "recv publish");
         }
-        srs_info("recv publish request message success.");
         
         SrsAutoFree(SrsCommonMessage, msg);
         SrsAutoFree(SrsPublishPacket, pkt);
@@ -3074,11 +2795,9 @@ int SrsRtmpServer::start_haivision_publish(int stream_id)
         pkt->data->set(StatusCode, SrsAmf0Any::str(StatusCodePublishStart));
         pkt->data->set(StatusDescription, SrsAmf0Any::str("Started publishing stream."));
         
-        if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-            srs_error("send onFCPublish(NetStream.Publish.Start) message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+            return srs_error_wrap(err, "send NetStream.Publish.Start");
         }
-        srs_info("send onFCPublish(NetStream.Publish.Start) message success.");
     }
     
     // publish response onStatus(NetStream.Publish.Start)
@@ -3090,21 +2809,17 @@ int SrsRtmpServer::start_haivision_publish(int stream_id)
         pkt->data->set(StatusDescription, SrsAmf0Any::str("Started publishing stream."));
         pkt->data->set(StatusClientId, SrsAmf0Any::str(RTMP_SIG_CLIENT_ID));
         
-        if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-            srs_error("send onStatus(NetStream.Publish.Start) message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+            return srs_error_wrap(err, "send NetStream.Publish.Start");
         }
-        srs_info("send onStatus(NetStream.Publish.Start) message success.");
     }
     
-    srs_info("Haivision publish success.");
-    
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::fmle_unpublish(int stream_id, double unpublish_tid)
+srs_error_t SrsRtmpServer::fmle_unpublish(int stream_id, double unpublish_tid)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err =srs_success;
     
     // publish response onFCUnpublish(NetStream.unpublish.Success)
     if (true) {
@@ -3114,24 +2829,16 @@ int SrsRtmpServer::fmle_unpublish(int stream_id, double unpublish_tid)
         pkt->data->set(StatusCode, SrsAmf0Any::str(StatusCodeUnpublishSuccess));
         pkt->data->set(StatusDescription, SrsAmf0Any::str("Stop publishing stream."));
         
-        if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-            if (!srs_is_system_control_error(ret) && !srs_is_client_gracefully_close(ret)) {
-                srs_error("send onFCUnpublish(NetStream.unpublish.Success) message failed. ret=%d", ret);
-            }
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+            return srs_error_wrap(err, "send NetStream.unpublish.Success");
         }
-        srs_info("send onFCUnpublish(NetStream.unpublish.Success) message success.");
     }
     // FCUnpublish response
     if (true) {
         SrsFMLEStartResPacket* pkt = new SrsFMLEStartResPacket(unpublish_tid);
-        if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-            if (!srs_is_system_control_error(ret) && !srs_is_client_gracefully_close(ret)) {
-                srs_error("send FCUnpublish response message failed. ret=%d", ret);
-            }
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+            return srs_error_wrap(err, "send FCUnpublish response");
         }
-        srs_info("send FCUnpublish response message success.");
     }
     // publish response onStatus(NetStream.Unpublish.Success)
     if (true) {
@@ -3142,23 +2849,17 @@ int SrsRtmpServer::fmle_unpublish(int stream_id, double unpublish_tid)
         pkt->data->set(StatusDescription, SrsAmf0Any::str("Stream is now unpublished"));
         pkt->data->set(StatusClientId, SrsAmf0Any::str(RTMP_SIG_CLIENT_ID));
         
-        if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-            if (!srs_is_system_control_error(ret) && !srs_is_client_gracefully_close(ret)) {
-                srs_error("send onStatus(NetStream.Unpublish.Success) message failed. ret=%d", ret);
-            }
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+            return srs_error_wrap(err, "send NetStream.Unpublish.Success");
         }
-        srs_info("send onStatus(NetStream.Unpublish.Success) message success.");
     }
     
-    srs_info("FMLE unpublish success.");
-    
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::start_flash_publish(int stream_id)
+srs_error_t SrsRtmpServer::start_flash_publish(int stream_id)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     // publish response onStatus(NetStream.Publish.Start)
     if (true) {
@@ -3169,38 +2870,29 @@ int SrsRtmpServer::start_flash_publish(int stream_id)
         pkt->data->set(StatusDescription, SrsAmf0Any::str("Started publishing stream."));
         pkt->data->set(StatusClientId, SrsAmf0Any::str(RTMP_SIG_CLIENT_ID));
         
-        if ((ret = protocol->send_and_free_packet(pkt, stream_id)) != ERROR_SUCCESS) {
-            srs_error("send onStatus(NetStream.Publish.Start) message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, stream_id)) != srs_success) {
+            return srs_error_wrap(err, "send NetStream.Publish.Start");
         }
-        srs_info("send onStatus(NetStream.Publish.Start) message success.");
     }
     
-    srs_info("flash publish success.");
-    
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::identify_create_stream_client(SrsCreateStreamPacket* req, int stream_id, SrsRtmpConnType& type, string& stream_name, double& duration)
+srs_error_t SrsRtmpServer::identify_create_stream_client(SrsCreateStreamPacket* req, int stream_id, SrsRtmpConnType& type, string& stream_name, double& duration)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     if (true) {
         SrsCreateStreamResPacket* pkt = new SrsCreateStreamResPacket(req->transaction_id, stream_id);
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            srs_error("send createStream response message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send createStream response");
         }
-        srs_info("send createStream response message success.");
     }
     
     while (true) {
         SrsCommonMessage* msg = NULL;
-        if ((ret = protocol->recv_message(&msg)) != ERROR_SUCCESS) {
-            if (!srs_is_client_gracefully_close(ret)) {
-                srs_error("recv identify client message failed. ret=%d", ret);
-            }
-            return ret;
+        if ((err = protocol->recv_message(&msg)) != srs_success) {
+            return srs_error_wrap(err, "recv identify");
         }
         
         SrsAutoFree(SrsCommonMessage, msg);
@@ -3211,45 +2903,39 @@ int SrsRtmpServer::identify_create_stream_client(SrsCreateStreamPacket* req, int
         }
         
         if (!h.is_amf0_command() && !h.is_amf3_command()) {
-            srs_trace("identify ignore messages except "
-                      "AMF0/AMF3 command message. type=%#x", h.message_type);
+            srs_trace("ignore message type=%#x", h.message_type);
             continue;
         }
         
         SrsPacket* pkt = NULL;
-        if ((ret = protocol->decode_message(msg, &pkt)) != ERROR_SUCCESS) {
-            srs_error("identify decode message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->decode_message(msg, &pkt)) != srs_success) {
+            return srs_error_wrap(err, "decode identify");
         }
         
         SrsAutoFree(SrsPacket, pkt);
         
         if (dynamic_cast<SrsPlayPacket*>(pkt)) {
-            srs_info("level1 identify client by play.");
             return identify_play_client(dynamic_cast<SrsPlayPacket*>(pkt), type, stream_name, duration);
         }
         if (dynamic_cast<SrsPublishPacket*>(pkt)) {
-            srs_info("identify client by publish, falsh publish.");
             return identify_flash_publish_client(dynamic_cast<SrsPublishPacket*>(pkt), type, stream_name);
         }
         if (dynamic_cast<SrsCreateStreamPacket*>(pkt)) {
-            srs_info("identify client by create stream, play or flash publish.");
             return identify_create_stream_client(dynamic_cast<SrsCreateStreamPacket*>(pkt), stream_id, type, stream_name, duration);
         }
         if (dynamic_cast<SrsFMLEStartPacket*>(pkt)) {
-            srs_info("identify client by FCPublish, haivision publish.");
             return identify_haivision_publish_client(dynamic_cast<SrsFMLEStartPacket*>(pkt), type, stream_name);
         }
         
         srs_trace("ignore AMF0/AMF3 command message.");
     }
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::identify_fmle_publish_client(SrsFMLEStartPacket* req, SrsRtmpConnType& type, string& stream_name)
+srs_error_t SrsRtmpServer::identify_fmle_publish_client(SrsFMLEStartPacket* req, SrsRtmpConnType& type, string& stream_name)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     type = SrsRtmpConnFMLEPublish;
     stream_name = req->stream_name;
@@ -3257,19 +2943,17 @@ int SrsRtmpServer::identify_fmle_publish_client(SrsFMLEStartPacket* req, SrsRtmp
     // releaseStream response
     if (true) {
         SrsFMLEStartResPacket* pkt = new SrsFMLEStartResPacket(req->transaction_id);
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            srs_error("send releaseStream response message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send releaseStream response");
         }
-        srs_info("send releaseStream response message success.");
     }
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::identify_haivision_publish_client(SrsFMLEStartPacket* req, SrsRtmpConnType& type, string& stream_name)
+srs_error_t SrsRtmpServer::identify_haivision_publish_client(SrsFMLEStartPacket* req, SrsRtmpConnType& type, string& stream_name)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     type = SrsRtmpConnHaivisionPublish;
     stream_name = req->stream_name;
@@ -3277,37 +2961,29 @@ int SrsRtmpServer::identify_haivision_publish_client(SrsFMLEStartPacket* req, Sr
     // FCPublish response
     if (true) {
         SrsFMLEStartResPacket* pkt = new SrsFMLEStartResPacket(req->transaction_id);
-        if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
-            srs_error("send FCPublish response message failed. ret=%d", ret);
-            return ret;
+        if ((err = protocol->send_and_free_packet(pkt, 0)) != srs_success) {
+            return srs_error_wrap(err, "send FCPublish");
         }
-        srs_info("send FCPublish response message success.");
     }
     
-    return ret;
+    return err;
 }
 
-int SrsRtmpServer::identify_flash_publish_client(SrsPublishPacket* req, SrsRtmpConnType& type, string& stream_name)
+srs_error_t SrsRtmpServer::identify_flash_publish_client(SrsPublishPacket* req, SrsRtmpConnType& type, string& stream_name)
 {
-    int ret = ERROR_SUCCESS;
-    
     type = SrsRtmpConnFlashPublish;
     stream_name = req->stream_name;
     
-    return ret;
+    return srs_success;
 }
 
-int SrsRtmpServer::identify_play_client(SrsPlayPacket* req, SrsRtmpConnType& type, string& stream_name, double& duration)
+srs_error_t SrsRtmpServer::identify_play_client(SrsPlayPacket* req, SrsRtmpConnType& type, string& stream_name, double& duration)
 {
-    int ret = ERROR_SUCCESS;
-    
     type = SrsRtmpConnPlay;
     stream_name = req->stream_name;
     duration = req->duration;
     
-    srs_info("identity client type=play, stream_name=%s, duration=%.2f", stream_name.c_str(), duration);
-    
-    return ret;
+    return srs_success;
 }
 
 SrsConnectAppPacket::SrsConnectAppPacket()
@@ -3325,37 +3001,28 @@ SrsConnectAppPacket::~SrsConnectAppPacket()
     srs_freep(args);
 }
 
-int SrsConnectAppPacket::decode(SrsBuffer* stream)
+srs_error_t SrsConnectAppPacket::decode(SrsBuffer* stream)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
-    if ((ret = srs_amf0_read_string(stream, command_name)) != ERROR_SUCCESS) {
-        srs_error("amf0 decode connect command_name failed. ret=%d", ret);
-        return ret;
+    if ((err = srs_amf0_read_string(stream, command_name)) != srs_success) {
+        return srs_error_wrap(err, "command_name");
     }
     if (command_name.empty() || command_name != RTMP_AMF0_COMMAND_CONNECT) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_error("amf0 decode connect command_name failed. "
-                  "command_name=%s, ret=%d", command_name.c_str(), ret);
-        return ret;
+        return srs_error_new(ERROR_RTMP_AMF0_DECODE, "invalid command_name=%s", command_name.c_str());
     }
     
-    if ((ret = srs_amf0_read_number(stream, transaction_id)) != ERROR_SUCCESS) {
-        srs_error("amf0 decode connect transaction_id failed. ret=%d", ret);
-        return ret;
+    if ((err = srs_amf0_read_number(stream, transaction_id)) != srs_success) {
+        return srs_error_wrap(err, "transaction_id");
     }
     
     // some client donot send id=1.0, so we only warn user if not match.
     if (transaction_id != 1.0) {
-        ret = ERROR_RTMP_AMF0_DECODE;
-        srs_warn("amf0 decode connect transaction_id failed. "
-                 "required=%.1f, actual=%.1f, ret=%d", 1.0, transaction_id, ret);
-        ret = ERROR_SUCCESS;
+        srs_warn("invalid transaction_id=%.2f", transaction_id);
     }
     
-    if ((ret = command_object->read(stream)) != ERROR_SUCCESS) {
-        srs_error("amf0 decode connect command_object failed. ret=%d", ret);
-        return ret;
+    if ((err = command_object->read(stream)) != srs_success) {
+        return srs_error_wrap(err, "command_object");
     }
     
     if (!stream->empty()) {
@@ -3364,17 +3031,15 @@ int SrsConnectAppPacket::decode(SrsBuffer* stream)
         // see: https://github.com/ossrs/srs/issues/186
         // the args maybe any amf0, for instance, a string. we should drop if not object.
         SrsAmf0Any* any = NULL;
-        if ((ret = SrsAmf0Any::discovery(stream, &any)) != ERROR_SUCCESS) {
-            srs_error("amf0 find connect args failed. ret=%d", ret);
-            return ret;
+        if ((err = SrsAmf0Any::discovery(stream, &any)) != srs_success) {
+            return srs_error_wrap(err, "args");
         }
         srs_assert(any);
         
         // read the instance
-        if ((ret = any->read(stream)) != ERROR_SUCCESS) {
-            srs_error("amf0 decode connect args failed. ret=%d", ret);
+        if ((err = any->read(stream)) != srs_success) {
             srs_freep(any);
-            return ret;
+            return srs_error_wrap(err, "args");
         }
         
         // drop when not an AMF0 object.
@@ -3386,9 +3051,7 @@ int SrsConnectAppPacket::decode(SrsBuffer* stream)
         }
     }
     
-    srs_info("amf0 decode connect packet success");
-    
-    return ret;
+    return err;
 }
 
 int SrsConnectAppPacket::get_prefer_cid()
@@ -3415,7 +3078,7 @@ int SrsConnectAppPacket::get_size()
     return size;
 }
 
-int SrsConnectAppPacket::encode_packet(SrsBuffer* stream)
+srs_error_t SrsConnectAppPacket::encode_packet(SrsBuffer* stream)
 {
     int ret = ERROR_SUCCESS;
     
diff --git a/trunk/src/protocol/srs_rtmp_stack.hpp b/trunk/src/protocol/srs_rtmp_stack.hpp
index 73a78dc00..8458e1643 100644
--- a/trunk/src/protocol/srs_rtmp_stack.hpp
+++ b/trunk/src/protocol/srs_rtmp_stack.hpp
@@ -142,15 +142,15 @@ public:
      * other packet which need to serialize/encode to bytes by override the
      * get_size and encode_packet.
      */
-    virtual int encode(int& size, char*& payload);
-    // decode functions for concrete packet to override.
+    virtual srs_error_t encode(int& size, char*& payload);
+// decode functions for concrete packet to override.
 public:
     /**
      * subpacket must override to decode packet from stream.
      * @remark never invoke the super.decode, it always failed.
      */
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     /**
      * the cid(chunk id) specifies the chunk to send data over.
@@ -173,7 +173,7 @@ protected:
      * subpacket can override to encode the payload to stream.
      * @remark never invoke the super.encode_packet, it always failed.
      */
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 /**
@@ -207,7 +207,7 @@ private:
      * value: the request command name
      */
     std::map<double, std::string> requests;
-    // peer in
+// peer in
 private:
     /**
      * chunk stream to decode RTMP messages.
@@ -247,7 +247,7 @@ private:
      * when not auto response message, manual flush the messages in queue.
      */
     std::vector<SrsPacket*> manual_response_queue;
-    // peer out
+// peer out
 private:
     /**
      * cache for multiple messages send,
@@ -287,7 +287,7 @@ public:
      * need to call this api(the protocol sdk will auto send message).
      * @see the auto_response_when_recv and manual_response_queue.
      */
-    virtual int manual_response_flush();
+    virtual srs_error_t manual_response_flush();
 public:
 #ifdef SRS_PERF_MERGED_READ
     /**
@@ -333,7 +333,7 @@ public:
     // because it wait for server to send acknowledge, but server default to 0 which means no need
     // to ack encoder. We can change the default input ack size. We will always response the
     // ack size whatever the encoder set or not.
-    virtual int set_in_window_ack_size(int ack_size);
+    virtual srs_error_t set_in_window_ack_size(int ack_size);
 public:
     /**
      * recv a RTMP message, which is bytes oriented.
@@ -344,14 +344,14 @@ public:
      *       never NULL if decode success.
      * @remark, drop message when msg is empty or payload length is empty.
      */
-    virtual int recv_message(SrsCommonMessage** pmsg);
+    virtual srs_error_t recv_message(SrsCommonMessage** pmsg);
     /**
      * decode bytes oriented RTMP message to RTMP packet,
      * @param ppacket, output decoded packet,
      *       always NULL if error, never NULL if success.
      * @return error when unknown packet, error when decode failed.
      */
-    virtual int decode_message(SrsCommonMessage* msg, SrsPacket** ppacket);
+    virtual srs_error_t decode_message(SrsCommonMessage* msg, SrsPacket** ppacket);
     /**
      * send the RTMP message and always free it.
      * user must never free or use the msg after this method,
@@ -359,7 +359,7 @@ public:
      * @param msg, the msg to send out, never be NULL.
      * @param stream_id, the stream id of packet to send over, 0 for control message.
      */
-    virtual int send_and_free_message(SrsSharedPtrMessage* msg, int stream_id);
+    virtual srs_error_t send_and_free_message(SrsSharedPtrMessage* msg, int stream_id);
     /**
      * send the RTMP message and always free it.
      * user must never free or use the msg after this method,
@@ -368,7 +368,7 @@ public:
      * @param nb_msgs, the size of msgs to send out.
      * @param stream_id, the stream id of packet to send over, 0 for control message.
      */
-    virtual int send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs, int stream_id);
+    virtual srs_error_t send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs, int stream_id);
     /**
      * send the RTMP packet and always free it.
      * user must never free or use the packet after this method,
@@ -376,7 +376,7 @@ public:
      * @param packet, the packet to send out, never be NULL.
      * @param stream_id, the stream id of packet to send over, 0 for control message.
      */
-    virtual int send_and_free_packet(SrsPacket* packet, int stream_id);
+    virtual srs_error_t send_and_free_packet(SrsPacket* packet, int stream_id);
 public:
     /**
      * expect a specified message, drop others util got specified one.
@@ -396,36 +396,28 @@ public:
      * if need to set timeout, use set timeout of SrsProtocol.
      */
     template<class T>
-    int expect_message(SrsCommonMessage** pmsg, T** ppacket)
+    srs_error_t expect_message(SrsCommonMessage** pmsg, T** ppacket)
     {
         *pmsg = NULL;
         *ppacket = NULL;
         
-        int ret = ERROR_SUCCESS;
+        srs_error_t err = srs_success;
         
         while (true) {
             SrsCommonMessage* msg = NULL;
-            if ((ret = recv_message(&msg)) != ERROR_SUCCESS) {
-                if (ret != ERROR_SOCKET_TIMEOUT && !srs_is_client_gracefully_close(ret)) {
-                    srs_error("recv message failed. ret=%d", ret);
-                }
-                return ret;
+            if ((err = recv_message(&msg)) != srs_success) {
+                return srs_error_wrap(err, "recv message");
             }
-            srs_verbose("recv message success.");
             
             SrsPacket* packet = NULL;
-            if ((ret = decode_message(msg, &packet)) != ERROR_SUCCESS) {
-                srs_error("decode message failed. ret=%d", ret);
+            if ((err = decode_message(msg, &packet)) != srs_success) {
                 srs_freep(msg);
                 srs_freep(packet);
-                return ret;
+                return srs_error_wrap(err, "decode message");
             }
             
             T* pkt = dynamic_cast<T*>(packet);
             if (!pkt) {
-                srs_info("drop message(type=%d, size=%d, time=%" PRId64 ", sid=%d).",
-                         msg->header.message_type, msg->header.payload_length,
-                         msg->header.timestamp, msg->header.stream_id);
                 srs_freep(msg);
                 srs_freep(packet);
                 continue;
@@ -436,70 +428,70 @@ public:
             break;
         }
         
-        return ret;
+        return err;
     }
 private:
     /**
      * send out the messages, donot free it,
      * the caller must free the param msgs.
      */
-    virtual int do_send_messages(SrsSharedPtrMessage** msgs, int nb_msgs);
+    virtual srs_error_t do_send_messages(SrsSharedPtrMessage** msgs, int nb_msgs);
     /**
      * send iovs. send multiple times if exceed limits.
      */
-    virtual int do_iovs_send(iovec* iovs, int size);
+    virtual srs_error_t do_iovs_send(iovec* iovs, int size);
     /**
      * underlayer api for send and free packet.
      */
-    virtual int do_send_and_free_packet(SrsPacket* packet, int stream_id);
+    virtual srs_error_t do_send_and_free_packet(SrsPacket* packet, int stream_id);
     /**
      * use simple algorithm to send the header and bytes.
      * @remark, for do_send_and_free_packet to send.
      */
-    virtual int do_simple_send(SrsMessageHeader* mh, char* payload, int size);
+    virtual srs_error_t do_simple_send(SrsMessageHeader* mh, char* payload, int size);
     /**
      * imp for decode_message
      */
-    virtual int do_decode_message(SrsMessageHeader& header, SrsBuffer* stream, SrsPacket** ppacket);
+    virtual srs_error_t do_decode_message(SrsMessageHeader& header, SrsBuffer* stream, SrsPacket** ppacket);
     /**
      * recv bytes oriented RTMP message from protocol stack.
      * return error if error occur and nerver set the pmsg,
      * return success and pmsg set to NULL if no entire message got,
      * return success and pmsg set to entire message if got one.
      */
-    virtual int recv_interlaced_message(SrsCommonMessage** pmsg);
+    virtual srs_error_t recv_interlaced_message(SrsCommonMessage** pmsg);
     /**
      * read the chunk basic header(fmt, cid) from chunk stream.
      * user can discovery a SrsChunkStream by cid.
      */
-    virtual int read_basic_header(char& fmt, int& cid);
+    virtual srs_error_t read_basic_header(char& fmt, int& cid);
     /**
      * read the chunk message header(timestamp, payload_length, message_type, stream_id)
      * from chunk stream and save to SrsChunkStream.
      */
-    virtual int read_message_header(SrsChunkStream* chunk, char fmt);
+    virtual srs_error_t read_message_header(SrsChunkStream* chunk, char fmt);
     /**
      * read the chunk payload, remove the used bytes in buffer,
      * if got entire message, set the pmsg.
      */
-    virtual int read_message_payload(SrsChunkStream* chunk, SrsCommonMessage** pmsg);
+    virtual srs_error_t read_message_payload(SrsChunkStream* chunk, SrsCommonMessage** pmsg);
     /**
      * when recv message, update the context.
      */
-    virtual int on_recv_message(SrsCommonMessage* msg);
+    virtual srs_error_t on_recv_message(SrsCommonMessage* msg);
     /**
      * when message sentout, update the context.
      */
-    virtual int on_send_packet(SrsMessageHeader* mh, SrsPacket* packet);
+    virtual srs_error_t on_send_packet(SrsMessageHeader* mh, SrsPacket* packet);
 private:
     /**
      * auto response the ack message.
      */
-    virtual int response_acknowledgement_message();
+    virtual srs_error_t response_acknowledgement_message();
     /**
      * auto response the ping message.
      */
-    virtual int response_ping_message(int32_t timestamp);
+    virtual srs_error_t response_ping_message(int32_t timestamp);
 private:
     virtual void print_debug_info();
 };
@@ -658,12 +650,12 @@ public:
     SrsHandshakeBytes();
     virtual ~SrsHandshakeBytes();
 public:
-    virtual int read_c0c1(ISrsProtocolReaderWriter* io);
-    virtual int read_s0s1s2(ISrsProtocolReaderWriter* io);
-    virtual int read_c2(ISrsProtocolReaderWriter* io);
-    virtual int create_c0c1();
-    virtual int create_s0s1s2(const char* c1 = NULL);
-    virtual int create_c2();
+    virtual srs_error_t read_c0c1(ISrsProtocolReaderWriter* io);
+    virtual srs_error_t read_s0s1s2(ISrsProtocolReaderWriter* io);
+    virtual srs_error_t read_c2(ISrsProtocolReaderWriter* io);
+    virtual srs_error_t create_c0c1();
+    virtual srs_error_t create_s0s1s2(const char* c1 = NULL);
+    virtual srs_error_t create_c2();
 };
 
 /**
@@ -696,30 +688,30 @@ protected:
 public:
     SrsRtmpClient(ISrsProtocolReaderWriter* skt);
     virtual ~SrsRtmpClient();
-    // protocol methods proxy
+// protocol methods proxy
 public:
     virtual void set_recv_timeout(int64_t tm);
     virtual void set_send_timeout(int64_t tm);
     virtual int64_t get_recv_bytes();
     virtual int64_t get_send_bytes();
-    virtual int recv_message(SrsCommonMessage** pmsg);
-    virtual int decode_message(SrsCommonMessage* msg, SrsPacket** ppacket);
-    virtual int send_and_free_message(SrsSharedPtrMessage* msg, int stream_id);
-    virtual int send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs, int stream_id);
-    virtual int send_and_free_packet(SrsPacket* packet, int stream_id);
+    virtual srs_error_t recv_message(SrsCommonMessage** pmsg);
+    virtual srs_error_t decode_message(SrsCommonMessage* msg, SrsPacket** ppacket);
+    virtual srs_error_t send_and_free_message(SrsSharedPtrMessage* msg, int stream_id);
+    virtual srs_error_t send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs, int stream_id);
+    virtual srs_error_t send_and_free_packet(SrsPacket* packet, int stream_id);
 public:
     /**
      * handshake with server, try complex, then simple handshake.
      */
-    virtual int handshake();
+    virtual srs_error_t handshake();
     /**
      * only use simple handshake
      */
-    virtual int simple_handshake();
+    virtual srs_error_t simple_handshake();
     /**
      * only use complex handshake
      */
-    virtual int complex_handshake();
+    virtual srs_error_t complex_handshake();
     /**
      * Connect to RTMP tcUrl and app, get the server info.
      *
@@ -729,25 +721,25 @@ public:
      * @param dsu, Whether debug SRS upnode. For edge, set to true to send its info to upnode.
      * @param si, The server information, retrieve from response of connect app request. NULL to ignore.
      */
-    virtual int connect_app(std::string app, std::string tcUrl, SrsRequest* r, bool dsu, SrsServerInfo* si);
+    virtual srs_error_t connect_app(std::string app, std::string tcUrl, SrsRequest* r, bool dsu, SrsServerInfo* si);
     /**
      * create a stream, then play/publish data over this stream.
      */
-    virtual int create_stream(int& stream_id);
+    virtual srs_error_t create_stream(int& stream_id);
     /**
      * start play stream.
      */
-    virtual int play(std::string stream, int stream_id);
+    virtual srs_error_t play(std::string stream, int stream_id);
     /**
      * start publish stream. use flash publish workflow:
      *       connect-app => create-stream => flash-publish
      */
-    virtual int publish(std::string stream, int stream_id);
+    virtual srs_error_t publish(std::string stream, int stream_id);
     /**
      * start publish stream. use FMLE publish workflow:
      *       connect-app => FMLE publish
      */
-    virtual int fmle_publish(std::string stream, int& stream_id);
+    virtual srs_error_t fmle_publish(std::string stream, int& stream_id);
 public:
     /**
      * expect a specified message, drop others util got specified one.
@@ -767,7 +759,7 @@ public:
      * if need to set timeout, use set timeout of SrsProtocol.
      */
     template<class T>
-    int expect_message(SrsCommonMessage** pmsg, T** ppacket)
+    srs_error_t expect_message(SrsCommonMessage** pmsg, T** ppacket)
     {
         return protocol->expect_message<T>(pmsg, ppacket);
     }
@@ -787,7 +779,7 @@ private:
 public:
     SrsRtmpServer(ISrsProtocolReaderWriter* skt);
     virtual ~SrsRtmpServer();
-    // protocol methods proxy
+// protocol methods proxy
 public:
     /**
      * set the auto response message when recv for protocol stack.
@@ -840,14 +832,14 @@ public:
      *       never NULL if decode success.
      * @remark, drop message when msg is empty or payload length is empty.
      */
-    virtual int recv_message(SrsCommonMessage** pmsg);
+    virtual srs_error_t recv_message(SrsCommonMessage** pmsg);
     /**
      * decode bytes oriented RTMP message to RTMP packet,
      * @param ppacket, output decoded packet,
      *       always NULL if error, never NULL if success.
      * @return error when unknown packet, error when decode failed.
      */
-    virtual int decode_message(SrsCommonMessage* msg, SrsPacket** ppacket);
+    virtual srs_error_t decode_message(SrsCommonMessage* msg, SrsPacket** ppacket);
     /**
      * send the RTMP message and always free it.
      * user must never free or use the msg after this method,
@@ -855,7 +847,7 @@ public:
      * @param msg, the msg to send out, never be NULL.
      * @param stream_id, the stream id of packet to send over, 0 for control message.
      */
-    virtual int send_and_free_message(SrsSharedPtrMessage* msg, int stream_id);
+    virtual srs_error_t send_and_free_message(SrsSharedPtrMessage* msg, int stream_id);
     /**
      * send the RTMP message and always free it.
      * user must never free or use the msg after this method,
@@ -867,7 +859,7 @@ public:
      * @remark performance issue, to support 6k+ 250kbps client,
      *       @see https://github.com/ossrs/srs/issues/194
      */
-    virtual int send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs, int stream_id);
+    virtual srs_error_t send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs, int stream_id);
     /**
      * send the RTMP packet and always free it.
      * user must never free or use the packet after this method,
@@ -875,37 +867,37 @@ public:
      * @param packet, the packet to send out, never be NULL.
      * @param stream_id, the stream id of packet to send over, 0 for control message.
      */
-    virtual int send_and_free_packet(SrsPacket* packet, int stream_id);
+    virtual srs_error_t send_and_free_packet(SrsPacket* packet, int stream_id);
 public:
     /**
      * handshake with client, try complex then simple.
      */
-    virtual int handshake();
+    virtual srs_error_t handshake();
     /**
      * do connect app with client, to discovery tcUrl.
      */
-    virtual int connect_app(SrsRequest* req);
+    virtual srs_error_t connect_app(SrsRequest* req);
     /**
      * set output ack size to client, client will send ack-size for each ack window
      */
-    virtual int set_window_ack_size(int ack_size);
+    virtual srs_error_t set_window_ack_size(int ack_size);
     // Set the default input ack size value.
-    virtual int set_in_window_ack_size(int ack_size);
+    virtual srs_error_t set_in_window_ack_size(int ack_size);
     /**
      * @type: The sender can mark this message hard (0), soft (1), or dynamic (2)
      * using the Limit type field.
      */
-    virtual int set_peer_bandwidth(int bandwidth, int type);
+    virtual srs_error_t set_peer_bandwidth(int bandwidth, int type);
     /**
      * @param server_ip the ip of server.
      */
-    virtual int response_connect_app(SrsRequest* req, const char* server_ip = NULL);
+    virtual srs_error_t response_connect_app(SrsRequest* req, const char* server_ip = NULL);
     /**
      * redirect the connection to another rtmp server.
      * @param the hostname or ip of target.
      * @param whether the client accept the redirect.
      */
-    virtual int redirect(SrsRequest* r, std::string host, int port, bool& accepted);
+    virtual srs_error_t redirect(SrsRequest* r, std::string host, int port, bool& accepted);
     /**
      * reject the connect app request.
      */
@@ -913,7 +905,7 @@ public:
     /**
      * response client the onBWDone message.
      */
-    virtual int on_bw_done();
+    virtual srs_error_t on_bw_done();
     /**
      * recv some message to identify the client.
      * @stream_id, client will createStream to play or publish by flash,
@@ -922,11 +914,11 @@ public:
      * @stream_name, output the client publish/play stream name. @see: SrsRequest.stream
      * @duration, output the play client duration. @see: SrsRequest.duration
      */
-    virtual int identify_client(int stream_id, SrsRtmpConnType& type, std::string& stream_name, double& duration);
+    virtual srs_error_t identify_client(int stream_id, SrsRtmpConnType& type, std::string& stream_name, double& duration);
     /**
      * set the chunk size when client type identified.
      */
-    virtual int set_chunk_size(int chunk_size);
+    virtual srs_error_t set_chunk_size(int chunk_size);
     /**
      * when client type is play, response with packets:
      * StreamBegin,
@@ -934,7 +926,7 @@ public:
      * |RtmpSampleAccess(false, false),
      * onStatus(NetStream.Data.Start).
      */
-    virtual int start_play(int stream_id);
+    virtual srs_error_t start_play(int stream_id);
     /**
      * when client(type is play) send pause message,
      * if is_pause, response the following packets:
@@ -944,7 +936,7 @@ public:
      *     onStatus(NetStream.Unpause.Notify)
      *     StreamBegin
      */
-    virtual int on_play_client_pause(int stream_id, bool is_pause);
+    virtual srs_error_t on_play_client_pause(int stream_id, bool is_pause);
     /**
      * when client type is publish, response with packets:
      * releaseStream response
@@ -954,22 +946,22 @@ public:
      * onFCPublish(NetStream.Publish.Start)
      * onStatus(NetStream.Publish.Start)
      */
-    virtual int start_fmle_publish(int stream_id);
+    virtual srs_error_t start_fmle_publish(int stream_id);
     /**
      * For encoder of Haivision, response the startup request.
      * @see https://github.com/ossrs/srs/issues/844
      */
-    virtual int start_haivision_publish(int stream_id);
+    virtual srs_error_t start_haivision_publish(int stream_id);
     /**
      * process the FMLE unpublish event.
      * @unpublish_tid the unpublish request transaction id.
      */
-    virtual int fmle_unpublish(int stream_id, double unpublish_tid);
+    virtual srs_error_t fmle_unpublish(int stream_id, double unpublish_tid);
     /**
      * when client type is publish, response with packets:
      * onStatus(NetStream.Publish.Start)
      */
-    virtual int start_flash_publish(int stream_id);
+    virtual srs_error_t start_flash_publish(int stream_id);
 public:
     /**
      * expect a specified message, drop others util got specified one.
@@ -989,17 +981,17 @@ public:
      * if need to set timeout, use set timeout of SrsProtocol.
      */
     template<class T>
-    int expect_message(SrsCommonMessage** pmsg, T** ppacket)
+    srs_error_t expect_message(SrsCommonMessage** pmsg, T** ppacket)
     {
         return protocol->expect_message<T>(pmsg, ppacket);
     }
 private:
-    virtual int identify_create_stream_client(SrsCreateStreamPacket* req, int stream_id, SrsRtmpConnType& type, std::string& stream_name, double& duration);
-    virtual int identify_fmle_publish_client(SrsFMLEStartPacket* req, SrsRtmpConnType& type, std::string& stream_name);
-    virtual int identify_haivision_publish_client(SrsFMLEStartPacket* req, SrsRtmpConnType& type, std::string& stream_name);
-    virtual int identify_flash_publish_client(SrsPublishPacket* req, SrsRtmpConnType& type, std::string& stream_name);
+    virtual srs_error_t identify_create_stream_client(SrsCreateStreamPacket* req, int stream_id, SrsRtmpConnType& type, std::string& stream_name, double& duration);
+    virtual srs_error_t identify_fmle_publish_client(SrsFMLEStartPacket* req, SrsRtmpConnType& type, std::string& stream_name);
+    virtual srs_error_t identify_haivision_publish_client(SrsFMLEStartPacket* req, SrsRtmpConnType& type, std::string& stream_name);
+    virtual srs_error_t identify_flash_publish_client(SrsPublishPacket* req, SrsRtmpConnType& type, std::string& stream_name);
 private:
-    virtual int identify_play_client(SrsPlayPacket* req, SrsRtmpConnType& type, std::string& stream_name, double& duration);
+    virtual srs_error_t identify_play_client(SrsPlayPacket* req, SrsRtmpConnType& type, std::string& stream_name, double& duration);
 };
 
 /**
@@ -1033,16 +1025,16 @@ public:
 public:
     SrsConnectAppPacket();
     virtual ~SrsConnectAppPacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 /**
  * response for SrsConnectAppPacket.
@@ -1072,16 +1064,16 @@ public:
 public:
     SrsConnectAppResPacket();
     virtual ~SrsConnectAppResPacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 /**
@@ -1115,16 +1107,16 @@ public:
 public:
     SrsCallPacket();
     virtual ~SrsCallPacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 /**
  * response for SrsCallPacket.
@@ -1153,13 +1145,13 @@ public:
 public:
     SrsCallResPacket(double _transaction_id);
     virtual ~SrsCallResPacket();
-    // encode functions for concrete packet to override.
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 /**
@@ -1188,16 +1180,16 @@ public:
 public:
     SrsCreateStreamPacket();
     virtual ~SrsCreateStreamPacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 /**
  * response for SrsCreateStreamPacket.
@@ -1225,16 +1217,16 @@ public:
 public:
     SrsCreateStreamResPacket(double _transaction_id, double _stream_id);
     virtual ~SrsCreateStreamResPacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 /**
@@ -1259,9 +1251,9 @@ public:
 public:
     SrsCloseStreamPacket();
     virtual ~SrsCloseStreamPacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
+    virtual srs_error_t decode(SrsBuffer* stream);
 };
 
 /**
@@ -1290,17 +1282,17 @@ public:
 public:
     SrsFMLEStartPacket();
     virtual ~SrsFMLEStartPacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
-    // factory method to create specified FMLE packet.
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
+// factory method to create specified FMLE packet.
 public:
     static SrsFMLEStartPacket* create_release_stream(std::string stream);
     static SrsFMLEStartPacket* create_FC_publish(std::string stream);
@@ -1332,16 +1324,16 @@ public:
 public:
     SrsFMLEStartResPacket(double _transaction_id);
     virtual ~SrsFMLEStartResPacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 /**
@@ -1387,16 +1379,16 @@ public:
 public:
     SrsPublishPacket();
     virtual ~SrsPublishPacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 /**
@@ -1434,9 +1426,9 @@ public:
 public:
     SrsPausePacket();
     virtual ~SrsPausePacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
+    virtual srs_error_t decode(SrsBuffer* stream);
 };
 
 /**
@@ -1506,16 +1498,16 @@ public:
 public:
     SrsPlayPacket();
     virtual ~SrsPlayPacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 /**
@@ -1549,13 +1541,13 @@ public:
 public:
     SrsPlayResPacket();
     virtual ~SrsPlayResPacket();
-    // encode functions for concrete packet to override.
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 /**
@@ -1580,13 +1572,13 @@ public:
 public:
     SrsOnBWDonePacket();
     virtual ~SrsOnBWDonePacket();
-    // encode functions for concrete packet to override.
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 /**
@@ -1618,13 +1610,13 @@ public:
 public:
     SrsOnStatusCallPacket();
     virtual ~SrsOnStatusCallPacket();
-    // encode functions for concrete packet to override.
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 /**
@@ -1658,17 +1650,17 @@ public:
 public:
     SrsBandwidthPacket();
     virtual ~SrsBandwidthPacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
-    // help function for bandwidth packet.
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
+// help function for bandwidth packet.
 public:
     virtual bool is_start_play();
     virtual bool is_starting_play();
@@ -1716,13 +1708,13 @@ public:
 public:
     SrsOnStatusDataPacket();
     virtual ~SrsOnStatusDataPacket();
-    // encode functions for concrete packet to override.
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 /**
@@ -1751,13 +1743,13 @@ public:
 public:
     SrsSampleAccessPacket();
     virtual ~SrsSampleAccessPacket();
-    // encode functions for concrete packet to override.
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 /**
@@ -1780,16 +1772,16 @@ public:
 public:
     SrsOnMetaDataPacket();
     virtual ~SrsOnMetaDataPacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 /**
@@ -1804,16 +1796,16 @@ public:
 public:
     SrsSetWindowAckSizePacket();
     virtual ~SrsSetWindowAckSizePacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 /**
@@ -1828,16 +1820,16 @@ public:
 public:
     SrsAcknowledgementPacket();
     virtual ~SrsAcknowledgementPacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 /**
@@ -1856,16 +1848,16 @@ public:
 public:
     SrsSetChunkSizePacket();
     virtual ~SrsSetChunkSizePacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 // 5.6. Set Peer Bandwidth (6)
@@ -1892,13 +1884,13 @@ public:
 public:
     SrsSetPeerBandwidthPacket();
     virtual ~SrsSetPeerBandwidthPacket();
-    // encode functions for concrete packet to override.
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 // 3.7. User Control message
@@ -2024,16 +2016,16 @@ public:
 public:
     SrsUserControlPacket();
     virtual ~SrsUserControlPacket();
-    // decode functions for concrete packet to override.
+// decode functions for concrete packet to override.
 public:
-    virtual int decode(SrsBuffer* stream);
-    // encode functions for concrete packet to override.
+    virtual srs_error_t decode(SrsBuffer* stream);
+// encode functions for concrete packet to override.
 public:
     virtual int get_prefer_cid();
     virtual int get_message_type();
 protected:
     virtual int get_size();
-    virtual int encode_packet(SrsBuffer* stream);
+    virtual srs_error_t encode_packet(SrsBuffer* stream);
 };
 
 #endif
diff --git a/trunk/src/service/srs_service_st.cpp b/trunk/src/service/srs_service_st.cpp
index 9feb8aedb..06fc77313 100644
--- a/trunk/src/service/srs_service_st.cpp
+++ b/trunk/src/service/srs_service_st.cpp
@@ -286,9 +286,9 @@ int64_t SrsStSocket::get_send_bytes()
     return sbytes;
 }
 
-int SrsStSocket::read(void* buf, size_t size, ssize_t* nread)
+srs_error_t SrsStSocket::read(void* buf, size_t size, ssize_t* nread)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     ssize_t nb_read;
     if (rtm == SRS_CONSTS_NO_TMMS) {
@@ -307,24 +307,24 @@ int SrsStSocket::read(void* buf, size_t size, ssize_t* nread)
     if (nb_read <= 0) {
         // @see https://github.com/ossrs/srs/issues/200
         if (nb_read < 0 && errno == ETIME) {
-            return ERROR_SOCKET_TIMEOUT;
+            return srs_error_new(ERROR_SOCKET_TIMEOUT, "timeout %d ms", (int)rtm);
         }
         
         if (nb_read == 0) {
             errno = ECONNRESET;
         }
         
-        return ERROR_SOCKET_READ;
+        return srs_error_new(ERROR_SOCKET_READ, "read");
     }
     
     rbytes += nb_read;
     
-    return ret;
+    return err;
 }
 
-int SrsStSocket::read_fully(void* buf, size_t size, ssize_t* nread)
+srs_error_t SrsStSocket::read_fully(void* buf, size_t size, ssize_t* nread)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     ssize_t nb_read;
     if (rtm == SRS_CONSTS_NO_TMMS) {
@@ -343,24 +343,24 @@ int SrsStSocket::read_fully(void* buf, size_t size, ssize_t* nread)
     if (nb_read != (ssize_t)size) {
         // @see https://github.com/ossrs/srs/issues/200
         if (nb_read < 0 && errno == ETIME) {
-            return ERROR_SOCKET_TIMEOUT;
+            return srs_error_new(ERROR_SOCKET_TIMEOUT, "timeout %d ms", (int)rtm);
         }
         
         if (nb_read >= 0) {
             errno = ECONNRESET;
         }
         
-        return ERROR_SOCKET_READ_FULLY;
+        return srs_error_new(ERROR_SOCKET_READ_FULLY, "read fully");
     }
     
     rbytes += nb_read;
     
-    return ret;
+    return err;
 }
 
-int SrsStSocket::write(void* buf, size_t size, ssize_t* nwrite)
+srs_error_t SrsStSocket::write(void* buf, size_t size, ssize_t* nwrite)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     ssize_t nb_write;
     if (stm == SRS_CONSTS_NO_TMMS) {
@@ -378,20 +378,20 @@ int SrsStSocket::write(void* buf, size_t size, ssize_t* nwrite)
     if (nb_write <= 0) {
         // @see https://github.com/ossrs/srs/issues/200
         if (nb_write < 0 && errno == ETIME) {
-            return ERROR_SOCKET_TIMEOUT;
+            return srs_error_new(ERROR_SOCKET_TIMEOUT, "write timeout %d ms", stm);
         }
         
-        return ERROR_SOCKET_WRITE;
+        return srs_error_new(ERROR_SOCKET_WRITE, "write");
     }
     
     sbytes += nb_write;
     
-    return ret;
+    return err;
 }
 
-int SrsStSocket::writev(const iovec *iov, int iov_size, ssize_t* nwrite)
+srs_error_t SrsStSocket::writev(const iovec *iov, int iov_size, ssize_t* nwrite)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     ssize_t nb_write;
     if (stm == SRS_CONSTS_NO_TMMS) {
@@ -409,15 +409,15 @@ int SrsStSocket::writev(const iovec *iov, int iov_size, ssize_t* nwrite)
     if (nb_write <= 0) {
         // @see https://github.com/ossrs/srs/issues/200
         if (nb_write < 0 && errno == ETIME) {
-            return ERROR_SOCKET_TIMEOUT;
+            return srs_error_new(ERROR_SOCKET_TIMEOUT, "writev timeout %d ms", stm);
         }
         
-        return ERROR_SOCKET_WRITE;
+        return srs_error_new(ERROR_SOCKET_WRITE, "writev");
     }
     
     sbytes += nb_write;
     
-    return ret;
+    return err;
 }
 
 SrsTcpClient::SrsTcpClient(string h, int p, int64_t tm)
@@ -500,22 +500,22 @@ int64_t SrsTcpClient::get_send_bytes()
     return io->get_send_bytes();
 }
 
-int SrsTcpClient::read(void* buf, size_t size, ssize_t* nread)
+srs_error_t SrsTcpClient::read(void* buf, size_t size, ssize_t* nread)
 {
     return io->read(buf, size, nread);
 }
 
-int SrsTcpClient::read_fully(void* buf, size_t size, ssize_t* nread)
+srs_error_t SrsTcpClient::read_fully(void* buf, size_t size, ssize_t* nread)
 {
     return io->read_fully(buf, size, nread);
 }
 
-int SrsTcpClient::write(void* buf, size_t size, ssize_t* nwrite)
+srs_error_t SrsTcpClient::write(void* buf, size_t size, ssize_t* nwrite)
 {
     return io->write(buf, size, nwrite);
 }
 
-int SrsTcpClient::writev(const iovec *iov, int iov_size, ssize_t* nwrite)
+srs_error_t SrsTcpClient::writev(const iovec *iov, int iov_size, ssize_t* nwrite)
 {
     return io->writev(iov, iov_size, nwrite);
 }
diff --git a/trunk/src/service/srs_service_st.hpp b/trunk/src/service/srs_service_st.hpp
index a900bdc12..e4ce4298d 100644
--- a/trunk/src/service/srs_service_st.hpp
+++ b/trunk/src/service/srs_service_st.hpp
@@ -139,13 +139,13 @@ public:
     /**
      * @param nread, the actual read bytes, ignore if NULL.
      */
-    virtual int read(void* buf, size_t size, ssize_t* nread);
-    virtual int read_fully(void* buf, size_t size, ssize_t* nread);
+    virtual srs_error_t read(void* buf, size_t size, ssize_t* nread);
+    virtual srs_error_t read_fully(void* buf, size_t size, ssize_t* nread);
     /**
      * @param nwrite, the actual write bytes, ignore if NULL.
      */
-    virtual int write(void* buf, size_t size, ssize_t* nwrite);
-    virtual int writev(const iovec *iov, int iov_size, ssize_t* nwrite);
+    virtual srs_error_t write(void* buf, size_t size, ssize_t* nwrite);
+    virtual srs_error_t writev(const iovec *iov, int iov_size, ssize_t* nwrite);
 };
 
 /**
@@ -198,10 +198,10 @@ public:
     virtual int64_t get_send_timeout();
     virtual int64_t get_recv_bytes();
     virtual int64_t get_send_bytes();
-    virtual int read(void* buf, size_t size, ssize_t* nread);
-    virtual int read_fully(void* buf, size_t size, ssize_t* nread);
-    virtual int write(void* buf, size_t size, ssize_t* nwrite);
-    virtual int writev(const iovec *iov, int iov_size, ssize_t* nwrite);
+    virtual srs_error_t read(void* buf, size_t size, ssize_t* nread);
+    virtual srs_error_t read_fully(void* buf, size_t size, ssize_t* nread);
+    virtual srs_error_t write(void* buf, size_t size, ssize_t* nwrite);
+    virtual srs_error_t writev(const iovec *iov, int iov_size, ssize_t* nwrite);
 };
 
 #endif