From patchwork Tue Apr 18 20:44:13 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella X-Patchwork-Id: 97579 Delivered-To: patch@linaro.org Received: by 10.140.109.52 with SMTP id k49csp23362qgf; Tue, 18 Apr 2017 13:44:36 -0700 (PDT) X-Received: by 10.84.177.164 with SMTP id x33mr25592707plb.147.1492548275948; Tue, 18 Apr 2017 13:44:35 -0700 (PDT) Return-Path: Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id i8si230713pfj.50.2017.04.18.13.44.35 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 18 Apr 2017 13:44:35 -0700 (PDT) Received-SPF: pass (google.com: domain of libc-alpha-return-78711-patch=linaro.org@sourceware.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Authentication-Results: mx.google.com; dkim=pass header.i=@sourceware.org; spf=pass (google.com: domain of libc-alpha-return-78711-patch=linaro.org@sourceware.org designates 209.132.180.131 as permitted sender) smtp.mailfrom=libc-alpha-return-78711-patch=linaro.org@sourceware.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org DomainKey-Signature: a=rsa-sha1; c=nofws; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:subject:date:message-id; q=dns; s= default; b=RwDQ43g3p9EDBvjJUhpVYeHXNlBwsQW2DbUXCddy8QgscAwWAB/vE pzwawXpnvThOR785yarAkfP1quTCqeatdKEjmQjmKkoJxtAP9ObUfuSrGeX6lAME b7LReT0tOoMf2ZqqnnX8KFB4bLQIs4bJI+qRAoP4awuSlJyK8xK33A= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:subject:date:message-id; s=default; bh=Lr5J81tePYcNft8UAyqe8Yc919g=; b=Tn8Ef2y5MYzvr2vxNiaU0Fd0bdc+ C9hpu2v5nNcCvb8faTT5+DtYUhJj669xDXELgm77/W10/SXjaM5jzZDkZh2I40ub m5+QTciimrii4hnfAGtE0IXitKBAZWUSmZ/IuU1XKPbBjIs/M3NyLnpN7Lc05lSV p0ThplLs7GrgvjI= Received: (qmail 80124 invoked by alias); 18 Apr 2017 20:44:22 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 80108 invoked by uid 89); 18 Apr 2017 20:44:21 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-24.5 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_DNSWL_NONE, RCVD_IN_SORBS_SPAM, SPF_PASS autolearn=ham version=3.3.2 spammy=resulted, 1147, 201608, 2615 X-HELO: mail-qk0-f178.google.com X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id; bh=shpUfyycPa05L7WSjkE2L7p/DM2c8VdqWFk/UP6x5to=; b=nBYtRirfcrTV7TpbYtZaRDJobejb7oVCP06d1H/OPKszO1hBK3HfznjR+Hneh2VS5g YUeDjPyfH2QiwlIS9I3kiwvZ3tcwZqroRG3Q5rhPtBCtzMblyp3EuI4bdC+MYdZxSEIk 2kWsCyc86L8GVV8Wx3CCgTn96eiiCCSe6qtTign1cuL6PgXZ8IjJcxi55oY1bxM7ZTo7 M94jHxlUfOByFc/pQ6uM8fJEuKbsroTAbTn9XvvjeOvHXstUb7FfjW+/7v1mqVCC1KOG 2GRgqaOYwofT0Z9rvU+FLTca1Xql1L2ARctiW2F7utiJ6bNF743VNs2X6I0C6hnqAGQg Wrlw== X-Gm-Message-State: AN3rC/5FMO2FPC1QHU3SBHE0eErkYHEmLPtvZFNXTjNiKFzyhDBRiIUU TrevU2OZR4t2dRWITXwZKQ== X-Received: by 10.233.235.4 with SMTP id b4mr15003697qkg.75.1492548258113; Tue, 18 Apr 2017 13:44:18 -0700 (PDT) From: Adhemerval Zanella To: libc-alpha@sourceware.org Subject: [PATCH] libio: Fix seek-past-end returned size for open_{w}memstream (BZ#15298) Date: Tue, 18 Apr 2017 17:44:13 -0300 Message-Id: <1492548253-2881-1-git-send-email-adhemerval.zanella@linaro.org> This is on my backlog for a long time, so I am resending. The only change from the previous iteration [1] is to adapt libio/tst-memstream3.c to use the support library. Florian, is my initial response suffice for patch inclusion? -- This patch fixes how open_{w}memstream updates the returned buffer size on a fclose/fflush operation. POSIX states [2]: "After a successful fflush() or fclose() [...] the variable pointed to by sizep shall contain the smaller of the current buffer length and the number of bytes for open_memstream(), or the number of wide characters for open_wmemstream(), between the beginning of the buffer and the current file position indicator." Current GLIBC behavior returns the seek position even if there is no previous write operation. To correctly report the buffer size the implementation must track both the buffer positiob and currently bytes written. However internal _IO_write_ptr is updated on both write and seek operations. This patch fixes it by adding two new internal fields to keep track of both previous and next position after a write operation. It allows the sync and close callbacks to know if a write has occurred based on previous and current _IO_write_ptr value. Tested on x86_64. [BZ #15298] * libio/memstream.c (_IO_FILE_memstream): Add prevwriteptr and seekwriteptr fields. (_IO_mem_seekoff): New function. (_IO_mem_jumps): Use _IO_mem_seekoff. (__open_memstream): Initialize prevwriteptr and seekwriteptr. (_IO_mem_sync): Update sizeloc based on written bytes instead of buffer current position. (_IO_mem_finish): Likewise. * libio/wmemstream.c (_IO_FILE_wmemstream): Add prevwriteptr and seekwriteptr fields. (_IO_wmem_seekoff): New function. (_IO_wmem_jumps): Use _IO_mem_seekoff. (__open_wmemstream): Initialize prevwriteptr and seekwriteptr. (_IO_mem_wsync): Update sizeloc based on written bytes instead of buffer current position. (_IO_mem_wfinish): Likewise. * libio/tst-memstream3.c (do_test_bz15298): New function. (do_test_bz18241): Check for expected size after a fseek followed by a fflush. (do_test): Call do_test_bz15298. [1] https://www.sourceware.org/ml/libc-alpha/2016-08/msg00837.html [2] http://pubs.opengroup.org/onlinepubs/9699919799/functions/open_memstream.html --- ChangeLog | 24 ++++++++++++++++ libio/memstream.c | 52 ++++++++++++++++++++++++++++++---- libio/tst-memstream3.c | 75 ++++++++++++++++++++++++++++++++++++++++++++++---- libio/wmemstream.c | 54 +++++++++++++++++++++++++++++++----- 4 files changed, 188 insertions(+), 17 deletions(-) -- 2.7.4 diff --git a/libio/memstream.c b/libio/memstream.c index f83d4a5..f600a16 100644 --- a/libio/memstream.c +++ b/libio/memstream.c @@ -26,12 +26,15 @@ struct _IO_FILE_memstream _IO_strfile _sf; char **bufloc; _IO_size_t *sizeloc; + char *prevwriteptr; + char *seekwriteptr; }; static int _IO_mem_sync (_IO_FILE* fp) __THROW; static void _IO_mem_finish (_IO_FILE* fp, int) __THROW; - +static _IO_off64_t _IO_mem_seekoff (_IO_FILE *fp, _IO_off64_t offset, + int dir, int mode) __THROW; static const struct _IO_jump_t _IO_mem_jumps libio_vtable = { @@ -43,7 +46,7 @@ static const struct _IO_jump_t _IO_mem_jumps libio_vtable = JUMP_INIT (pbackfail, _IO_str_pbackfail), JUMP_INIT (xsputn, _IO_default_xsputn), JUMP_INIT (xsgetn, _IO_default_xsgetn), - JUMP_INIT (seekoff, _IO_str_seekoff), + JUMP_INIT (seekoff, _IO_mem_seekoff), JUMP_INIT (seekpos, _IO_default_seekpos), JUMP_INIT (setbuf, _IO_default_setbuf), JUMP_INIT (sync, _IO_mem_sync), @@ -95,6 +98,24 @@ __open_memstream (char **bufloc, _IO_size_t *sizeloc) new_f->fp.bufloc = bufloc; new_f->fp.sizeloc = sizeloc; + /* To correctly report the buffer size the implementation must track both + the buffer size and currently bytes written. However _IO_write_ptr is + updated on both write and seek operations. So to track current written + bytes two fields are used: + + - prevwriteptr: track previous _IO_write_ptr before a seek operation on + the stream. + - seekwriteptr: track resulted _IO_write_ptr after a seek operation on + the stream. + + Also, prevwriteptr is only updated iff _IO_write_ptr changed over calls + (meaning that a write operation occured) + + So final buffer size is based on current _IO_write_ptr only if + its value is different than seekwriteptr, otherwise it uses the old + _IO_write_ptr value before seek operation (prevwriteptr). */ + new_f->fp.prevwriteptr = new_f->fp.seekwriteptr = + new_f->fp._sf._sbf._f._IO_write_ptr; return (_IO_FILE *) &new_f->fp._sf._sbf; } @@ -114,7 +135,9 @@ _IO_mem_sync (_IO_FILE *fp) } *mp->bufloc = fp->_IO_write_base; - *mp->sizeloc = fp->_IO_write_ptr - fp->_IO_write_base; + char *ptr = (fp->_IO_write_ptr == mp->seekwriteptr) + ? mp->prevwriteptr : fp->_IO_write_ptr; + *mp->sizeloc = ptr - fp->_IO_write_base; return 0; } @@ -129,11 +152,30 @@ _IO_mem_finish (_IO_FILE *fp, int dummy) fp->_IO_write_ptr - fp->_IO_write_base + 1); if (*mp->bufloc != NULL) { - (*mp->bufloc)[fp->_IO_write_ptr - fp->_IO_write_base] = '\0'; - *mp->sizeloc = fp->_IO_write_ptr - fp->_IO_write_base; + size_t len; + if (fp->_IO_write_ptr == mp->seekwriteptr) + len = mp->prevwriteptr - fp->_IO_write_base; + else + { + /* An '\0' should be appended iff a write operation ocurred. */ + len = fp->_IO_write_ptr - fp->_IO_write_base; + (*mp->bufloc)[len] = '\0'; + } + *mp->sizeloc = len; fp->_IO_buf_base = NULL; } _IO_str_finish (fp, 0); } + +static _IO_off64_t +_IO_mem_seekoff (_IO_FILE *fp, _IO_off64_t offset, int dir, int mode) +{ + struct _IO_FILE_memstream *mp = (struct _IO_FILE_memstream *) fp; + if (fp->_IO_write_ptr != mp->seekwriteptr) + mp->prevwriteptr = fp->_IO_write_ptr; + _IO_off64_t ret = _IO_str_seekoff (fp, offset, dir, mode); + mp->seekwriteptr = fp->_IO_write_ptr; + return ret; +} diff --git a/libio/tst-memstream3.c b/libio/tst-memstream3.c index ce201d1..f8dc465 100644 --- a/libio/tst-memstream3.c +++ b/libio/tst-memstream3.c @@ -59,6 +59,69 @@ error_printf (int line, const char *fmt, ...) { error_printf(__LINE__, __VA_ARGS__); return 1; } static int +do_test_bz15298 (void) +{ + CHAR_T *buf; + size_t size; + size_t ret; + + FILE *fp = OPEN_MEMSTREAM (&buf, &size); + if (fp == NULL) + ERROR_RET1 ("%s failed\n", S(OPEN_MEMSTREAM)); + + /* Move internal position but do not write any bytes. Final size should + be 0. */ + if (fseek (fp, 10, SEEK_SET) == -1) + ERROR_RET1 ("fseek failed (errno = %d)\n", errno); + if (fseek (fp, 20, SEEK_CUR) == -1) + ERROR_RET1 ("fseek failed (errno = %d)\n", errno); + if (fseek (fp, 30, SEEK_CUR) == -1) + ERROR_RET1 ("fseek failed (errno = %d)\n", errno); + if (fflush (fp) != 0) + ERROR_RET1 ("fflush failed (errno = %d)\n", errno); + if (size != 0) + ERROR_RET1 ("size != 0 (got %zu)\n", size); + + /* Now write some bytes and change internal position. Final size should + be based on written bytes. */ + if (fseek (fp, 0, SEEK_SET) == -1) + ERROR_RET1 ("fseek failed (errno = %d)\n", errno); + if ((ret = FWRITE (W("abc"), 1, 3, fp)) != 3) + ERROR_RET1 ("%s failed (errno = %d)\n", S(FWRITE), errno); + if (fseek (fp, 20, SEEK_CUR) == -1) + ERROR_RET1 ("fseek failed (errno = %d)\n", errno); + if (fseek (fp, 30, SEEK_CUR) == -1) + ERROR_RET1 ("fseek failed (errno = %d)\n", errno); + if (fflush (fp) != 0) + ERROR_RET1 ("fflush failed (errno = %d)\n", errno); + if (size != 3) + ERROR_RET1 ("size != 3 (got %zu)\n", size); + + /* Finally set position, write some bytes and change position again. Final + size should be based again on write position. */ + size_t offset = 2048; + if (fseek (fp, offset, SEEK_SET) == -1) + ERROR_RET1 ("fseek failed (errno = %d)\n", errno); + if ((ret = FWRITE (W("abc"), 1, 3, fp)) != 3) + ERROR_RET1 ("%s failed (errno = %d)\n", S(FWRITE), errno); + if (fseek (fp, 20, SEEK_CUR) == -1) + ERROR_RET1 ("fseek failed (errno = %d)\n", errno); + if (fseek (fp, 30, SEEK_CUR) == -1) + ERROR_RET1 ("fseek failed (errno = %d)\n", errno); + if (fflush (fp) != 0) + ERROR_RET1 ("fflush failed (errno = %d)\n", errno); + if (size != offset + 3) + ERROR_RET1 ("size != %zu (got %zu)\n", offset + 3, size); + + if (fclose (fp) != 0) + ERROR_RET1 ("fclose failed (errno = %d\n", errno); + + free (buf); + + return 0; +} + +static int do_test_bz18241 (void) { CHAR_T *buf; @@ -126,15 +189,17 @@ do_test_bz20181 (void) if (fflush (fp) != 0) ERROR_RET1 ("fflush failed (errno = %d)\n", errno); - /* Avoid truncating the buffer on close. */ + /* fseek updates the internal buffer, but open_memstream should set the + size to smaller of the buffer size and number of bytes written. Since + it was written just character ('z') final size should be 1. */ if (fseek (fp, 3, SEEK_SET) != 0) ERROR_RET1 ("fseek failed (errno = %d)\n", errno); if (fclose (fp) != 0) ERROR_RET1 ("fclose failed (errno = %d\n", errno); - if (size != 3) - ERROR_RET1 ("size != 3\n"); + if (size != 1) + ERROR_RET1 ("size != 1 (got %zu)\n", size); if (buf[0] != W('z') || buf[1] != W('b') @@ -157,11 +222,11 @@ do_test (void) mcheck_pedantic (mcheck_abort); + ret += do_test_bz15298 (); ret += do_test_bz18241 (); ret += do_test_bz20181 (); return ret; } -#define TEST_FUNCTION do_test () -#include "../test-skeleton.c" +#include diff --git a/libio/wmemstream.c b/libio/wmemstream.c index 5bc77f5..24d7e24 100644 --- a/libio/wmemstream.c +++ b/libio/wmemstream.c @@ -27,12 +27,15 @@ struct _IO_FILE_wmemstream _IO_strfile _sf; wchar_t **bufloc; _IO_size_t *sizeloc; + wchar_t *prevwriteptr; + wchar_t *seekwriteptr; }; static int _IO_wmem_sync (_IO_FILE* fp) __THROW; static void _IO_wmem_finish (_IO_FILE* fp, int) __THROW; - +static _IO_off64_t _IO_wmem_seekoff (_IO_FILE *fp, _IO_off64_t offset, + int dir, int mode) __THROW; static const struct _IO_jump_t _IO_wmem_jumps libio_vtable = { @@ -44,7 +47,7 @@ static const struct _IO_jump_t _IO_wmem_jumps libio_vtable = JUMP_INIT (pbackfail, (_IO_pbackfail_t) _IO_wstr_pbackfail), JUMP_INIT (xsputn, _IO_wdefault_xsputn), JUMP_INIT (xsgetn, _IO_wdefault_xsgetn), - JUMP_INIT (seekoff, _IO_wstr_seekoff), + JUMP_INIT (seekoff, _IO_wmem_seekoff), JUMP_INIT (seekpos, _IO_default_seekpos), JUMP_INIT (setbuf, _IO_default_setbuf), JUMP_INIT (sync, _IO_wmem_sync), @@ -97,6 +100,24 @@ open_wmemstream (wchar_t **bufloc, _IO_size_t *sizeloc) new_f->fp.bufloc = bufloc; new_f->fp.sizeloc = sizeloc; + /* To correctly report the buffer size the implementation must track both + the buffer size and currently bytes written. However _IO_write_ptr is + updated on both write and seek operations. So to track current written + bytes two fields are used: + + - prevwriteptr: track previous _IO_write_ptr before a seek operation on + the stream. + - seekwriteptr: track resulted _IO_write_ptr after a seek operation on + the stream. + + Also, prevwriteptr is only updated iff _IO_write_ptr changed over calls + (meaning that a write operation occured) + + So final buffer size is based on current _IO_write_ptr only if + its value is different than seekwriteptr, otherwise it uses the old + _IO_write_ptr value before seek operation (prevwriteptr). */ + new_f->fp.prevwriteptr = new_f->fp.seekwriteptr = + new_f->fp._sf._sbf._f._wide_data->_IO_write_ptr; return (_IO_FILE *) &new_f->fp._sf._sbf; } @@ -114,8 +135,9 @@ _IO_wmem_sync (_IO_FILE *fp) } *mp->bufloc = fp->_wide_data->_IO_write_base; - *mp->sizeloc = (fp->_wide_data->_IO_write_ptr - - fp->_wide_data->_IO_write_base); + wchar_t *ptr = (fp->_wide_data->_IO_write_ptr == mp->seekwriteptr) + ? mp->prevwriteptr : fp->_wide_data->_IO_write_ptr; + *mp->sizeloc = ptr - fp->_wide_data->_IO_write_base; return 0; } @@ -132,9 +154,16 @@ _IO_wmem_finish (_IO_FILE *fp, int dummy) * sizeof (wchar_t)); if (*mp->bufloc != NULL) { - size_t len = (fp->_wide_data->_IO_write_ptr - - fp->_wide_data->_IO_write_base); - (*mp->bufloc)[len] = '\0'; + size_t len; + if (fp->_wide_data->_IO_write_ptr == mp->seekwriteptr) + len = mp->prevwriteptr - fp->_wide_data->_IO_write_base; + else + { + /* An '\0' should be appended iff a write operation ocurred. */ + len = fp->_wide_data->_IO_write_ptr + - fp->_wide_data->_IO_write_base; + (*mp->bufloc)[len] = L'\0'; + } *mp->sizeloc = len; fp->_wide_data->_IO_buf_base = NULL; @@ -142,3 +171,14 @@ _IO_wmem_finish (_IO_FILE *fp, int dummy) _IO_wstr_finish (fp, 0); } + +static _IO_off64_t +_IO_wmem_seekoff (_IO_FILE *fp, _IO_off64_t offset, int dir, int mode) +{ + struct _IO_FILE_wmemstream *mp = (struct _IO_FILE_wmemstream *) fp; + if (fp->_wide_data->_IO_write_ptr != mp->seekwriteptr) + mp->prevwriteptr = fp->_wide_data->_IO_write_ptr; + _IO_off64_t ret = _IO_wstr_seekoff (fp, offset, dir, mode); + mp->seekwriteptr = fp->_wide_data->_IO_write_ptr; + return ret; +}