bpo-41486: Fix initial buffer size can't > UINT32_MAX in zlib module (GH-25738)

Ma Lin · web-flow · commit 251ffa9d2b16 · 2021-04-30T16:32:49.000-07:00
* Fix initial buffer size can't > UINT32_MAX in zlib module After commit f9bedb6, in 64-bit build, if the initial buffer size > UINT32_MAX, ValueError will be raised. These two functions are affected: 1. zlib.decompress(data, /, wbits=MAX_WBITS, bufsize=DEF_BUF_SIZE) 2. zlib.Decompress.flush([length]) This commit re-allows the size > UINT32_MAX. * adds curly braces per PEP 7. * Renames `Buffer_*` to `OutputBuffer_*` for clarity
diff --git a/Modules/_bz2module.c b/Modules/_bz2module.c
@@ -18,8 +18,8 @@
 /* On success, return value >= 0
    On failure, return -1 */
 static inline Py_ssize_t
-Buffer_InitAndGrow(_BlocksOutputBuffer *buffer, Py_ssize_t max_length,
-                   char **next_out, uint32_t *avail_out)
+OutputBuffer_InitAndGrow(_BlocksOutputBuffer *buffer, Py_ssize_t max_length,
+                         char **next_out, uint32_t *avail_out)
 {
     Py_ssize_t allocated;
 
@@ -32,8 +32,8 @@ Buffer_InitAndGrow(_BlocksOutputBuffer *buffer, Py_ssize_t max_length,
 /* On success, return value >= 0
    On failure, return -1 */
 static inline Py_ssize_t
-Buffer_Grow(_BlocksOutputBuffer *buffer,
-            char **next_out, uint32_t *avail_out)
+OutputBuffer_Grow(_BlocksOutputBuffer *buffer,
+                  char **next_out, uint32_t *avail_out)
 {
     Py_ssize_t allocated;
 
@@ -44,19 +44,19 @@ Buffer_Grow(_BlocksOutputBuffer *buffer,
 }
 
 static inline Py_ssize_t
-Buffer_GetDataSize(_BlocksOutputBuffer *buffer, uint32_t avail_out)
+OutputBuffer_GetDataSize(_BlocksOutputBuffer *buffer, uint32_t avail_out)
 {
     return _BlocksOutputBuffer_GetDataSize(buffer, (Py_ssize_t) avail_out);
 }
 
 static inline PyObject *
-Buffer_Finish(_BlocksOutputBuffer *buffer, uint32_t avail_out)
+OutputBuffer_Finish(_BlocksOutputBuffer *buffer, uint32_t avail_out)
 {
     return _BlocksOutputBuffer_Finish(buffer, (Py_ssize_t) avail_out);
 }
 
 static inline void
-Buffer_OnError(_BlocksOutputBuffer *buffer)
+OutputBuffer_OnError(_BlocksOutputBuffer *buffer)
 {
     _BlocksOutputBuffer_OnError(buffer);
 }
@@ -177,7 +177,7 @@ compress(BZ2Compressor *c, char *data, size_t len, int action)
     PyObject *result;
     _BlocksOutputBuffer buffer = {.list = NULL};
 
-    if (Buffer_InitAndGrow(&buffer, -1, &c->bzs.next_out, &c->bzs.avail_out) < 0) {
+    if (OutputBuffer_InitAndGrow(&buffer, -1, &c->bzs.next_out, &c->bzs.avail_out) < 0) {
         goto error;
     }
     c->bzs.next_in = data;
@@ -198,7 +198,7 @@ compress(BZ2Compressor *c, char *data, size_t len, int action)
             break;
 
         if (c->bzs.avail_out == 0) {
-            if (Buffer_Grow(&buffer, &c->bzs.next_out, &c->bzs.avail_out) < 0) {
+            if (OutputBuffer_Grow(&buffer, &c->bzs.next_out, &c->bzs.avail_out) < 0) {
                 goto error;
             }
         }
@@ -215,13 +215,13 @@ compress(BZ2Compressor *c, char *data, size_t len, int action)
             break;
     }
 
-    result = Buffer_Finish(&buffer, c->bzs.avail_out);
+    result = OutputBuffer_Finish(&buffer, c->bzs.avail_out);
     if (result != NULL) {
         return result;
     }
 
 error:
-    Buffer_OnError(&buffer);
+    OutputBuffer_OnError(&buffer);
     return NULL;
 }
 
@@ -442,7 +442,7 @@ decompress_buf(BZ2Decompressor *d, Py_ssize_t max_length)
     _BlocksOutputBuffer buffer = {.list = NULL};
     bz_stream *bzs = &d->bzs;
 
-    if (Buffer_InitAndGrow(&buffer, max_length, &bzs->next_out, &bzs->avail_out) < 0) {
+    if (OutputBuffer_InitAndGrow(&buffer, max_length, &bzs->next_out, &bzs->avail_out) < 0) {
         goto error;
     }
 
@@ -469,21 +469,22 @@ decompress_buf(BZ2Decompressor *d, Py_ssize_t max_length)
         } else if (d->bzs_avail_in_real == 0) {
             break;
         } else if (bzs->avail_out == 0) {
-            if (Buffer_GetDataSize(&buffer, bzs->avail_out) == max_length)
+            if (OutputBuffer_GetDataSize(&buffer, bzs->avail_out) == max_length) {
                 break;
-            if (Buffer_Grow(&buffer, &bzs->next_out, &bzs->avail_out) < 0) {
+            }
+            if (OutputBuffer_Grow(&buffer, &bzs->next_out, &bzs->avail_out) < 0) {
                 goto error;
             }
         }
     }
 
-    result = Buffer_Finish(&buffer, bzs->avail_out);
+    result = OutputBuffer_Finish(&buffer, bzs->avail_out);
     if (result != NULL) {
         return result;
     }
 
 error:
-    Buffer_OnError(&buffer);
+    OutputBuffer_OnError(&buffer);
     return NULL;
 }
 
diff --git a/Modules/_lzmamodule.c b/Modules/_lzmamodule.c
@@ -25,8 +25,8 @@
 /* On success, return value >= 0
    On failure, return -1 */
 static inline Py_ssize_t
-Buffer_InitAndGrow(_BlocksOutputBuffer *buffer, Py_ssize_t max_length,
-                   uint8_t **next_out, size_t *avail_out)
+OutputBuffer_InitAndGrow(_BlocksOutputBuffer *buffer, Py_ssize_t max_length,
+                         uint8_t **next_out, size_t *avail_out)
 {
     Py_ssize_t allocated;
 
@@ -39,8 +39,8 @@ Buffer_InitAndGrow(_BlocksOutputBuffer *buffer, Py_ssize_t max_length,
 /* On success, return value >= 0
    On failure, return -1 */
 static inline Py_ssize_t
-Buffer_Grow(_BlocksOutputBuffer *buffer,
-            uint8_t **next_out, size_t *avail_out)
+OutputBuffer_Grow(_BlocksOutputBuffer *buffer,
+                  uint8_t **next_out, size_t *avail_out)
 {
     Py_ssize_t allocated;
 
@@ -51,19 +51,19 @@ Buffer_Grow(_BlocksOutputBuffer *buffer,
 }
 
 static inline Py_ssize_t
-Buffer_GetDataSize(_BlocksOutputBuffer *buffer, size_t avail_out)
+OutputBuffer_GetDataSize(_BlocksOutputBuffer *buffer, size_t avail_out)
 {
     return _BlocksOutputBuffer_GetDataSize(buffer, (Py_ssize_t) avail_out);
 }
 
 static inline PyObject *
-Buffer_Finish(_BlocksOutputBuffer *buffer, size_t avail_out)
+OutputBuffer_Finish(_BlocksOutputBuffer *buffer, size_t avail_out)
 {
     return _BlocksOutputBuffer_Finish(buffer, (Py_ssize_t) avail_out);
 }
 
 static inline void
-Buffer_OnError(_BlocksOutputBuffer *buffer)
+OutputBuffer_OnError(_BlocksOutputBuffer *buffer)
 {
     _BlocksOutputBuffer_OnError(buffer);
 }
@@ -550,7 +550,7 @@ compress(Compressor *c, uint8_t *data, size_t len, lzma_action action)
     _lzma_state *state = PyType_GetModuleState(Py_TYPE(c));
     assert(state != NULL);
 
-    if (Buffer_InitAndGrow(&buffer, -1, &c->lzs.next_out, &c->lzs.avail_out) < 0) {
+    if (OutputBuffer_InitAndGrow(&buffer, -1, &c->lzs.next_out, &c->lzs.avail_out) < 0) {
         goto error;
     }
     c->lzs.next_in = data;
@@ -573,19 +573,19 @@ compress(Compressor *c, uint8_t *data, size_t len, lzma_action action)
             (action == LZMA_FINISH && lzret == LZMA_STREAM_END)) {
             break;
         } else if (c->lzs.avail_out == 0) {
-            if (Buffer_Grow(&buffer, &c->lzs.next_out, &c->lzs.avail_out) < 0) {
+            if (OutputBuffer_Grow(&buffer, &c->lzs.next_out, &c->lzs.avail_out) < 0) {
                 goto error;
             }
         }
     }
 
-    result = Buffer_Finish(&buffer, c->lzs.avail_out);
+    result = OutputBuffer_Finish(&buffer, c->lzs.avail_out);
     if (result != NULL) {
         return result;
     }
 
 error:
-    Buffer_OnError(&buffer);
+    OutputBuffer_OnError(&buffer);
     return NULL;
 }
 
@@ -934,7 +934,7 @@ decompress_buf(Decompressor *d, Py_ssize_t max_length)
     _lzma_state *state = PyType_GetModuleState(Py_TYPE(d));
     assert(state != NULL);
 
-    if (Buffer_InitAndGrow(&buffer, max_length, &lzs->next_out, &lzs->avail_out) < 0) {
+    if (OutputBuffer_InitAndGrow(&buffer, max_length, &lzs->next_out, &lzs->avail_out) < 0) {
         goto error;
     }
 
@@ -962,24 +962,24 @@ decompress_buf(Decompressor *d, Py_ssize_t max_length)
                Maybe lzs's internal state still have a few bytes
                can be output, grow the output buffer and continue
                if max_lengh < 0. */
-            if (Buffer_GetDataSize(&buffer, lzs->avail_out) == max_length) {
+            if (OutputBuffer_GetDataSize(&buffer, lzs->avail_out) == max_length) {
                 break;
             }
-            if (Buffer_Grow(&buffer, &lzs->next_out, &lzs->avail_out) < 0) {
+            if (OutputBuffer_Grow(&buffer, &lzs->next_out, &lzs->avail_out) < 0) {
                 goto error;
             }
         } else if (lzs->avail_in == 0) {
             break;
         }
     }
 
-    result = Buffer_Finish(&buffer, lzs->avail_out);
+    result = OutputBuffer_Finish(&buffer, lzs->avail_out);
     if (result != NULL) {
         return result;
     }
 
 error:
-    Buffer_OnError(&buffer);
+    OutputBuffer_OnError(&buffer);
     return NULL;
 }
 
diff --git a/Modules/zlibmodule.c b/Modules/zlibmodule.c

Original file line number	Diff line number	Diff line change
`@@ -18,8 +18,8 @@`
`18`	`18`	`/* On success, return value >= 0`
`19`	`19`	`On failure, return -1 */`
`20`	`20`	`static inline Py_ssize_t`
`21`		`-Buffer_InitAndGrow(_BlocksOutputBuffer *buffer, Py_ssize_t max_length,`
`22`		`- char *next_out, uint32_t avail_out)`
	`21`	`+OutputBuffer_InitAndGrow(_BlocksOutputBuffer *buffer, Py_ssize_t max_length,`
	`22`	`+ char *next_out, uint32_t avail_out)`
`23`	`23`	`{`
`24`	`24`	`Py_ssize_t allocated;`
`25`	`25`
`@@ -32,8 +32,8 @@ Buffer_InitAndGrow(_BlocksOutputBuffer *buffer, Py_ssize_t max_length,`
`32`	`32`	`/* On success, return value >= 0`
`33`	`33`	`On failure, return -1 */`
`34`	`34`	`static inline Py_ssize_t`
`35`		`-Buffer_Grow(_BlocksOutputBuffer *buffer,`
`36`		`- char *next_out, uint32_t avail_out)`
	`35`	`+OutputBuffer_Grow(_BlocksOutputBuffer *buffer,`
	`36`	`+ char *next_out, uint32_t avail_out)`
`37`	`37`	`{`
`38`	`38`	`Py_ssize_t allocated;`
`39`	`39`
`@@ -44,19 +44,19 @@ Buffer_Grow(_BlocksOutputBuffer *buffer,`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`static inline Py_ssize_t`
`47`		`-Buffer_GetDataSize(_BlocksOutputBuffer *buffer, uint32_t avail_out)`
	`47`	`+OutputBuffer_GetDataSize(_BlocksOutputBuffer *buffer, uint32_t avail_out)`
`48`	`48`	`{`
`49`	`49`	`return _BlocksOutputBuffer_GetDataSize(buffer, (Py_ssize_t) avail_out);`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`static inline PyObject *`
`53`		`-Buffer_Finish(_BlocksOutputBuffer *buffer, uint32_t avail_out)`
	`53`	`+OutputBuffer_Finish(_BlocksOutputBuffer *buffer, uint32_t avail_out)`
`54`	`54`	`{`
`55`	`55`	`return _BlocksOutputBuffer_Finish(buffer, (Py_ssize_t) avail_out);`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`static inline void`
`59`		`-Buffer_OnError(_BlocksOutputBuffer *buffer)`
	`59`	`+OutputBuffer_OnError(_BlocksOutputBuffer *buffer)`
`60`	`60`	`{`
`61`	`61`	`_BlocksOutputBuffer_OnError(buffer);`
`62`	`62`	`}`
`@@ -177,7 +177,7 @@ compress(BZ2Compressor c, char data, size_t len, int action)`
`177`	`177`	`PyObject *result;`
`178`	`178`	`_BlocksOutputBuffer buffer = {.list = NULL};`
`179`	`179`
`180`		`- if (Buffer_InitAndGrow(&buffer, -1, &c->bzs.next_out, &c->bzs.avail_out) < 0) {`
	`180`	`+ if (OutputBuffer_InitAndGrow(&buffer, -1, &c->bzs.next_out, &c->bzs.avail_out) < 0) {`
`181`	`181`	`goto error;`
`182`	`182`	`}`
`183`	`183`	`c->bzs.next_in = data;`
`@@ -198,7 +198,7 @@ compress(BZ2Compressor c, char data, size_t len, int action)`
`198`	`198`	`break;`
`199`	`199`
`200`	`200`	`if (c->bzs.avail_out == 0) {`
`201`		`- if (Buffer_Grow(&buffer, &c->bzs.next_out, &c->bzs.avail_out) < 0) {`
	`201`	`+ if (OutputBuffer_Grow(&buffer, &c->bzs.next_out, &c->bzs.avail_out) < 0) {`
`202`	`202`	`goto error;`
`203`	`203`	`}`
`204`	`204`	`}`
`@@ -215,13 +215,13 @@ compress(BZ2Compressor c, char data, size_t len, int action)`
`215`	`215`	`break;`
`216`	`216`	`}`
`217`	`217`
`218`		`- result = Buffer_Finish(&buffer, c->bzs.avail_out);`
	`218`	`+ result = OutputBuffer_Finish(&buffer, c->bzs.avail_out);`
`219`	`219`	`if (result != NULL) {`
`220`	`220`	`return result;`
`221`	`221`	`}`
`222`	`222`
`223`	`223`	`error:`
`224`		`- Buffer_OnError(&buffer);`
	`224`	`+ OutputBuffer_OnError(&buffer);`
`225`	`225`	`return NULL;`
`226`	`226`	`}`
`227`	`227`
`@@ -442,7 +442,7 @@ decompress_buf(BZ2Decompressor *d, Py_ssize_t max_length)`
`442`	`442`	`_BlocksOutputBuffer buffer = {.list = NULL};`
`443`	`443`	`bz_stream *bzs = &d->bzs;`
`444`	`444`
`445`		`- if (Buffer_InitAndGrow(&buffer, max_length, &bzs->next_out, &bzs->avail_out) < 0) {`
	`445`	`+ if (OutputBuffer_InitAndGrow(&buffer, max_length, &bzs->next_out, &bzs->avail_out) < 0) {`
`446`	`446`	`goto error;`
`447`	`447`	`}`
`448`	`448`
`@@ -469,21 +469,22 @@ decompress_buf(BZ2Decompressor *d, Py_ssize_t max_length)`
`469`	`469`	`} else if (d->bzs_avail_in_real == 0) {`
`470`	`470`	`break;`
`471`	`471`	`} else if (bzs->avail_out == 0) {`
`472`		`- if (Buffer_GetDataSize(&buffer, bzs->avail_out) == max_length)`
	`472`	`+ if (OutputBuffer_GetDataSize(&buffer, bzs->avail_out) == max_length) {`
`473`	`473`	`break;`
`474`		`- if (Buffer_Grow(&buffer, &bzs->next_out, &bzs->avail_out) < 0) {`
	`474`	`+ }`
	`475`	`+ if (OutputBuffer_Grow(&buffer, &bzs->next_out, &bzs->avail_out) < 0) {`
`475`	`476`	`goto error;`
`476`	`477`	`}`
`477`	`478`	`}`
`478`	`479`	`}`
`479`	`480`
`480`		`- result = Buffer_Finish(&buffer, bzs->avail_out);`
	`481`	`+ result = OutputBuffer_Finish(&buffer, bzs->avail_out);`
`481`	`482`	`if (result != NULL) {`
`482`	`483`	`return result;`
`483`	`484`	`}`
`484`	`485`
`485`	`486`	`error:`
`486`		`- Buffer_OnError(&buffer);`
	`487`	`+ OutputBuffer_OnError(&buffer);`
`487`	`488`	`return NULL;`
`488`	`489`	`}`
`489`	`490`
Original file line number	Diff line number	Diff line change
`@@ -25,8 +25,8 @@`
`25`	`25`	`/* On success, return value >= 0`
`26`	`26`	`On failure, return -1 */`
`27`	`27`	`static inline Py_ssize_t`
`28`		`-Buffer_InitAndGrow(_BlocksOutputBuffer *buffer, Py_ssize_t max_length,`
`29`		`- uint8_t *next_out, size_t avail_out)`
	`28`	`+OutputBuffer_InitAndGrow(_BlocksOutputBuffer *buffer, Py_ssize_t max_length,`
	`29`	`+ uint8_t *next_out, size_t avail_out)`
`30`	`30`	`{`
`31`	`31`	`Py_ssize_t allocated;`
`32`	`32`
`@@ -39,8 +39,8 @@ Buffer_InitAndGrow(_BlocksOutputBuffer *buffer, Py_ssize_t max_length,`
`39`	`39`	`/* On success, return value >= 0`
`40`	`40`	`On failure, return -1 */`
`41`	`41`	`static inline Py_ssize_t`
`42`		`-Buffer_Grow(_BlocksOutputBuffer *buffer,`
`43`		`- uint8_t *next_out, size_t avail_out)`
	`42`	`+OutputBuffer_Grow(_BlocksOutputBuffer *buffer,`
	`43`	`+ uint8_t *next_out, size_t avail_out)`
`44`	`44`	`{`
`45`	`45`	`Py_ssize_t allocated;`
`46`	`46`
`@@ -51,19 +51,19 @@ Buffer_Grow(_BlocksOutputBuffer *buffer,`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`static inline Py_ssize_t`
`54`		`-Buffer_GetDataSize(_BlocksOutputBuffer *buffer, size_t avail_out)`
	`54`	`+OutputBuffer_GetDataSize(_BlocksOutputBuffer *buffer, size_t avail_out)`
`55`	`55`	`{`
`56`	`56`	`return _BlocksOutputBuffer_GetDataSize(buffer, (Py_ssize_t) avail_out);`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`static inline PyObject *`
`60`		`-Buffer_Finish(_BlocksOutputBuffer *buffer, size_t avail_out)`
	`60`	`+OutputBuffer_Finish(_BlocksOutputBuffer *buffer, size_t avail_out)`
`61`	`61`	`{`
`62`	`62`	`return _BlocksOutputBuffer_Finish(buffer, (Py_ssize_t) avail_out);`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`static inline void`
`66`		`-Buffer_OnError(_BlocksOutputBuffer *buffer)`
	`66`	`+OutputBuffer_OnError(_BlocksOutputBuffer *buffer)`
`67`	`67`	`{`
`68`	`68`	`_BlocksOutputBuffer_OnError(buffer);`
`69`	`69`	`}`
`@@ -550,7 +550,7 @@ compress(Compressor c, uint8_t data, size_t len, lzma_action action)`
`550`	`550`	`_lzma_state *state = PyType_GetModuleState(Py_TYPE(c));`
`551`	`551`	`assert(state != NULL);`
`552`	`552`
`553`		`- if (Buffer_InitAndGrow(&buffer, -1, &c->lzs.next_out, &c->lzs.avail_out) < 0) {`
	`553`	`+ if (OutputBuffer_InitAndGrow(&buffer, -1, &c->lzs.next_out, &c->lzs.avail_out) < 0) {`
`554`	`554`	`goto error;`
`555`	`555`	`}`
`556`	`556`	`c->lzs.next_in = data;`
`@@ -573,19 +573,19 @@ compress(Compressor c, uint8_t data, size_t len, lzma_action action)`
`573`	`573`	`(action == LZMA_FINISH && lzret == LZMA_STREAM_END)) {`
`574`	`574`	`break;`
`575`	`575`	`} else if (c->lzs.avail_out == 0) {`
`576`		`- if (Buffer_Grow(&buffer, &c->lzs.next_out, &c->lzs.avail_out) < 0) {`
	`576`	`+ if (OutputBuffer_Grow(&buffer, &c->lzs.next_out, &c->lzs.avail_out) < 0) {`
`577`	`577`	`goto error;`
`578`	`578`	`}`
`579`	`579`	`}`
`580`	`580`	`}`
`581`	`581`
`582`		`- result = Buffer_Finish(&buffer, c->lzs.avail_out);`
	`582`	`+ result = OutputBuffer_Finish(&buffer, c->lzs.avail_out);`
`583`	`583`	`if (result != NULL) {`
`584`	`584`	`return result;`
`585`	`585`	`}`
`586`	`586`
`587`	`587`	`error:`
`588`		`- Buffer_OnError(&buffer);`
	`588`	`+ OutputBuffer_OnError(&buffer);`
`589`	`589`	`return NULL;`
`590`	`590`	`}`
`591`	`591`
`@@ -934,7 +934,7 @@ decompress_buf(Decompressor *d, Py_ssize_t max_length)`
`934`	`934`	`_lzma_state *state = PyType_GetModuleState(Py_TYPE(d));`
`935`	`935`	`assert(state != NULL);`
`936`	`936`
`937`		`- if (Buffer_InitAndGrow(&buffer, max_length, &lzs->next_out, &lzs->avail_out) < 0) {`
	`937`	`+ if (OutputBuffer_InitAndGrow(&buffer, max_length, &lzs->next_out, &lzs->avail_out) < 0) {`
`938`	`938`	`goto error;`
`939`	`939`	`}`
`940`	`940`
`@@ -962,24 +962,24 @@ decompress_buf(Decompressor *d, Py_ssize_t max_length)`
`962`	`962`	`Maybe lzs's internal state still have a few bytes`
`963`	`963`	`can be output, grow the output buffer and continue`
`964`	`964`	`if max_lengh < 0. */`
`965`		`- if (Buffer_GetDataSize(&buffer, lzs->avail_out) == max_length) {`
	`965`	`+ if (OutputBuffer_GetDataSize(&buffer, lzs->avail_out) == max_length) {`
`966`	`966`	`break;`
`967`	`967`	`}`
`968`		`- if (Buffer_Grow(&buffer, &lzs->next_out, &lzs->avail_out) < 0) {`
	`968`	`+ if (OutputBuffer_Grow(&buffer, &lzs->next_out, &lzs->avail_out) < 0) {`
`969`	`969`	`goto error;`
`970`	`970`	`}`
`971`	`971`	`} else if (lzs->avail_in == 0) {`
`972`	`972`	`break;`
`973`	`973`	`}`
`974`	`974`	`}`
`975`	`975`
`976`		`- result = Buffer_Finish(&buffer, lzs->avail_out);`
	`976`	`+ result = OutputBuffer_Finish(&buffer, lzs->avail_out);`
`977`	`977`	`if (result != NULL) {`
`978`	`978`	`return result;`
`979`	`979`	`}`
`980`	`980`
`981`	`981`	`error:`
`982`		`- Buffer_OnError(&buffer);`
	`982`	`+ OutputBuffer_OnError(&buffer);`
`983`	`983`	`return NULL;`
`984`	`984`	`}`
`985`	`985`