Attachment #254197 for bug #282047

Lines 1-3 Link Here

(-)b/contrib/libarchive/NEWS (+6 lines)
		1	Oct 13, 2024: libarchive 3.7.7 released
		2
		3	Sep 23, 2024: libarchive 3.7.6 released
		4
		5	Sep 13, 2024: libarchive 3.7.5 released
		6
1	Apr 26, 2024: libarchive 3.7.4 released	7	Apr 26, 2024: libarchive 3.7.4 released
2		8
3	Apr 08, 2024: libarchive 3.7.3 released	9	Apr 08, 2024: libarchive 3.7.3 released




.\" Copyright (c) 2011-2014, Mike Kazantsev
.\" All rights reserved.
.\"
.\" SPDX-License-Identifier: BSD-2-Clause
.\" modification, are permitted provided that the following conditions
.\" are met:
.\" 1. Redistributions of source code must retain the above copyright
.\"    notice, this list of conditions and the following disclaimer.
.\" 2. Redistributions in binary form must reproduce the above copyright
.\"    notice, this list of conditions and the following disclaimer in the
.\"    documentation and/or other materials provided with the distribution.
.\"
.\" Copyright (c) 2011-2014, Mike Kazantsev
.\" All rights reserved.
.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
.\" SUCH DAMAGE.
.\"
.Dd March 1, 2014
.Dt BSDCAT 1

.Nm
typically takes a filename as an argument or reads standard input when used in a
pipe.
In both cases decompressed data is written to standard output.
.Sh EXAMPLES
To decompress a file:
.Pp




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2011-2014, Mike Kazantsev
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "bsdcat_platform.h"




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014, Mike Kazantsev
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef BSDCAT_H_INCLUDED




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*

#define __LA_NORETURN       __attribute__((__noreturn__))
#elif defined(_MSC_VER)
#define __LA_NORETURN __declspec(noreturn)
#else
#define __LA_NORETURN
#endif





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2008 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*




/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2006 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/* Every test program should #include "test.h" as the first thing. */




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Sebastian Freundt
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Sebastian Freundt
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Sebastian Freundt
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2017 Sean Purcell
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Mike Kazantsev
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Mike Kazantsev
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Mike Kazantsev
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Mike Kazantsev
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Mike Kazantsev
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Mike Kazantsev
 * Copyright (c) 2012, 2014 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Mike Kazantsev
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Mike Kazantsev
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Mike Kazantsev
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2017 Sean Purcell
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2017 Sean Purcell
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2017 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





.\" Copyright (c) 2003-2007 Tim Kientzle
.\" All rights reserved.
.\"
.\" SPDX-License-Identifier: BSD-2-Clause
.\" modification, are permitted provided that the following conditions
.\" are met:
.\" 1. Redistributions of source code must retain the above copyright
.\"    notice, this list of conditions and the following disclaimer.
.\" 2. Redistributions in binary form must reproduce the above copyright
.\"    notice, this list of conditions and the following disclaimer in the
.\"    documentation and/or other materials provided with the distribution.
.\"
.\" Copyright (c) 2003-2007 Tim Kientzle
.\" All rights reserved.
.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
.\" SUCH DAMAGE.
.\"
.Dd September 16, 2014
.Dt CPIO 1




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */



 * Returns NULL if no error, otherwise returns error string for display.
 *
 */
int
owner_parse(const char *spec, struct cpio_owner *owner, const char **errmsg)
{
	static char errbuff[128];
	const char *u, *ue, *g;

	owner->uid = -1;
	owner->gid = -1;

	owner->uname = NULL;
	owner->gname = NULL;

	if (spec[0] == '\0') {
		*errmsg = "Invalid empty user/group spec";
		return (-1);
	}

	/*
	 * Split spec into [user][:.][group]

		char *user;
		struct passwd *pwent;

		user = malloc(ue - u + 1);
		if (user == NULL)
			goto alloc_error;
		memcpy(user, u, ue - u);
		user[ue - u] = '\0';
		if ((pwent = getpwnam(user)) != NULL) {
			owner->uid = pwent->pw_uid;
			owner->uname = strdup(pwent->pw_name);
			if (owner->uname == NULL) {
				free(user);
				goto alloc_error;
			}
			if (*ue != '\0')
				owner->gid = pwent->pw_gid;
		} else {
			char *end;
			errno = 0;
			owner->uid = (int)strtoul(user, &end, 10);
			if (errno || *end != '\0') {
				snprintf(errbuff, sizeof(errbuff),
				    "Couldn't lookup user ``%s''", user);
				errbuff[sizeof(errbuff) - 1] = '\0';
				free(user);
				*errmsg = errbuff;
				return (-1);
			}
		}
		free(user);

	if (*g != '\0') {
		struct group *grp;
		if ((grp = getgrnam(g)) != NULL) {
			owner->gid = grp->gr_gid;
			owner->gname = strdup(grp->gr_name);
			if (owner->gname == NULL) {
				free(owner->uname);
				owner->uname = NULL;
				goto alloc_error;
			}
		} else {
			char *end;
			errno = 0;
			owner->gid = (int)strtoul(g, &end, 10);
			if (errno || *end != '\0') {
				snprintf(errbuff, sizeof(errbuff),
				    "Couldn't lookup group ``%s''", g);
				errbuff[sizeof(errbuff) - 1] = '\0';
				*errmsg = errbuff;
				return (-1);
			}
		}
	}
	return (0);
alloc_error:
	*errmsg = "Couldn't allocate memory";
	return (-1);
}




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */



	static char buff[16384];
	struct cpio _cpio; /* Allocated on stack. */
	struct cpio *cpio;
	struct cpio_owner owner;
	const char *errmsg;
	char *tptr;
	int uid, gid;
	int opt, t;

	cpio = &_cpio;

	cpio->buff = buff;
	cpio->buff_size = sizeof(buff);


#if defined(HAVE_SIGACTION) && defined(SIGPIPE)
	{ /* Ignore SIGPIPE signals. */
		struct sigaction sa;

#endif

	cpio->uid_override = -1;
	cpio->uname_override = NULL;
	cpio->gid_override = -1;
	cpio->gname_override = NULL;
	cpio->argv = argv;
	cpio->argc = argc;
	cpio->mode = '\0';

			cpio->quiet = 1;
			break;
		case 'R': /* GNU cpio, also --owner */
			errmsg = NULL;
			if (owner_parse(cpio->argument, &owner, &errmsg) != 0) {
				if (!errmsg)
					errmsg = "Error parsing owner";
				lafe_warnc(-1, "%s", errmsg);
				usage();
			}
			if (owner.uid != -1)
				cpio->uid_override = owner.uid;
			if (owner.uname != NULL)
				cpio->uname_override = owner.uname;
			if (owner.gid != -1)
				cpio->gid_override = owner.gid;
			if (owner.gname != NULL)
				cpio->gname_override = owner.gname;
			break;
		case 'r': /* POSIX 1997 */
			cpio->option_rename = 1;

	}

	archive_match_free(cpio->matching);
	free_cache(cpio->gname_cache);
	free_cache(cpio->uname_cache);
	free(cpio->uname_override);
	free_cache(cpio->gname_cache);
	free(cpio->gname_override);
	archive_read_close(cpio->archive_read_disk);
	archive_read_free(cpio->archive_read_disk);
	free(cpio->destdir);

	passphrase_free(cpio->ppbuff);
	return (cpio->return_value);
}

		return (r);
	}

	if (cpio->uid_override >= 0)
		archive_entry_set_uid(entry, cpio->uid_override);
	if (cpio->gname_override != NULL)
		archive_entry_set_uname(entry, cpio->uname_override);
	if (cpio->gid_override >= 0)
	if (cpio->gid_override >= 0) {
		archive_entry_set_gid(entry, cpio->gid_override);
	if (cpio->gname_override != NULL)
		archive_entry_set_gname(entry, cpio->gname_override);
	}

	/*
	 * Generate a destination path for this entry.

			fprintf(stderr, ".");
		if (cpio->uid_override >= 0)
			archive_entry_set_uid(entry, cpio->uid_override);
		if (cpio->uname_override != NULL)
			archive_entry_set_uname(entry, cpio->uname_override);
		if (cpio->gid_override >= 0)
			archive_entry_set_gid(entry, cpio->gid_override);
		if (cpio->gname_override != NULL)
			archive_entry_set_gname(entry, cpio->gname_override);
		r = archive_write_header(ext, entry);
		if (r != ARCHIVE_OK) {
			fprintf(stderr, "%s: %s\n",
			    archive_entry_pathname(entry),
			    archive_error_string(ext));
			cpio->return_value = 1;
		} else if (!archive_entry_size_is_set(entry)
		    || archive_entry_size(entry) > 0) {
			r = extract_data(a, ext);




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef CPIO_H_INCLUDED

	char		 *ppbuff;
};

struct cpio_owner {
        int uid;
        int gid;
        char *uname;
        char *gname;
};

int owner_parse(const char *, struct cpio_owner *, const char **);

/* Fake short equivalents for long options that otherwise lack them. */
enum {




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*




/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2017 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/* Every test program should #include "test.h" as the first thing. */




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2009 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2024 Mostyn Bramley-Moore <mostyn@antipode.se>
 */

#include "test.h"

#include <stdlib.h>
#include <string.h>

#if defined(_WIN32) && !defined(__CYGWIN__)
#define UNLINK _unlink
#else
#define UNLINK unlink
#endif

DEFINE_TEST(test_extract_cpio_absolute_paths)
{
	int r;

	// Create an absolute path for a test file inside testworkdir.
	const char *entry_suffix = "/cpio-noabs";
	size_t entry_suffix_length = strlen(entry_suffix);
	size_t testworkdir_length = strlen(testworkdir);
	size_t temp_absolute_file_name_length = testworkdir_length + entry_suffix_length;
	char *temp_absolute_file_name = calloc(1, temp_absolute_file_name_length + 1); // +1 for null character.
	assertEqualInt(snprintf(temp_absolute_file_name, temp_absolute_file_name_length + 1, "%s%s", testworkdir, entry_suffix),
		temp_absolute_file_name_length);

	// Create the file.
	const char *sample_data = "test file from test_extract_cpio_absolute_paths";
	assertMakeFile(temp_absolute_file_name, 0644, sample_data);

	// Create an archive with the test file, using an absolute path.
	assertMakeFile("filelist", 0644, temp_absolute_file_name);
	r = systemf("%s -o < filelist > archive.cpio 2> stderr1.txt", testprog);
	assertEqualInt(r, 0);

	// Ensure that the temp file does not exist.
	UNLINK(temp_absolute_file_name);

	// We should refuse to create the absolute path without --insecure.
	r = systemf("%s -i < archive.cpio 2> stderr2.txt", testprog);
	assert(r != 0);
	assertFileNotExists(temp_absolute_file_name);
	UNLINK(temp_absolute_file_name); // Cleanup just in case.

	// But if we specify --insecure then the absolute path should be created.
	r = systemf("%s -i --insecure < archive.cpio 2> stderr3.txt", testprog);
	assert(r == 0);
	assertFileExists(temp_absolute_file_name);
}




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012,2014 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2017 Sean Purcell
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"


	assertEqualMem(e + 0, "070701", 6); /* Magic */
	ino = from_hex(e + 6, 8); /* ino */
#if defined(_WIN32) && !defined(__CYGWIN__)
	/* Group members bits and others bits do not work. */
	assertEqualInt(0x8180, from_hex(e + 14, 8) & 0xffc0); /* Mode */
#else
	assertEqualInt(0x81a4, from_hex(e + 14, 8)); /* Mode */
#endif
#if defined(_WIN32)
	uid = from_hex(e + 22, 8);
#else

	failure("If these aren't the same, then the hardlink detection failed to match them.");
	assertEqualInt(ino, from_hex(e + 6, 8)); /* ino */
#if defined(_WIN32) && !defined(__CYGWIN__)
	/* Group members bits and others bits do not work. */
	assertEqualInt(0x8180, from_hex(e + 14, 8) & 0xffc0); /* Mode */
#else
	assertEqualInt(0x81a4, from_hex(e + 14, 8)); /* Mode */




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2016 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2010 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2009 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2009 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2008 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"
#if defined(HAVE_UTIME_H)




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"


	assert(is_octal(e, 76)); /* Entire header is octal digits. */
	assertEqualMem(e + 0, "070707", 6); /* Magic */
	assert(is_octal(e + 6, 6)); /* dev */
	dev = (int)from_octal(e + 6, 6);
	assert(is_octal(e + 12, 6)); /* ino */
	ino = (int)from_octal(e + 12, 6);
#if defined(_WIN32) && !defined(__CYGWIN__)
	/* Group members bits and others bits do not work. */
	assertEqualMem(e + 18, "100666", 6); /* Mode */

	assertEqualMem(e + 18, "100644", 6); /* Mode */
#endif
	if (uid < 0)
		uid = (int)from_octal(e + 24, 6);
	assertEqualInt(from_octal(e + 24, 6), uid); /* uid */
	assert(is_octal(e + 30, 6)); /* gid */
	gid = (int)from_octal(e + 30, 6);
	assertEqualMem(e + 36, "000001", 6); /* nlink */
	failure("file entries should not have rdev set (dev field was 0%o)",
	    dev);




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"


	assertMakeDir("without-d", 0755);
	assertChdir("without-d");
	r = systemf("%s -i < ../archive.cpio >out 2>err", testprog);
	assert(r != 0);
	assertEmptyFile("out");
	/* And the file should not be restored. */
	assertFileNotExists("dir/file");




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"


	char *p;
	int r;
	time_t mtime;
	char date[48];
	char date2[32];
	struct tm *tmptr;
#if defined(HAVE_LOCALTIME_R) || defined(HAVE_LOCALTIME_S)

	mtime = 1;
#ifdef HAVE_LOCALE_H
	setlocale(LC_ALL, "");
	setlocale(LC_TIME, "");
#endif
#if defined(HAVE_LOCALTIME_S)
        tmptr = localtime_s(&tmbuf, &mtime) ? NULL : &tmbuf;

#endif
#if defined(_WIN32) && !defined(__CYGWIN__)
	strftime(date2, sizeof(date2)-1, "%b %d  %Y", tmptr);
	_snprintf(date, sizeof(date)-1, "%12s file", date2);
#else
	strftime(date2, sizeof(date2)-1, "%b %e  %Y", tmptr);
	snprintf(date, sizeof(date)-1, "%12s file", date2);
#endif
	assertEqualMem(p + 42, date, strlen(date));
	free(p);




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"
#if defined(HAVE_UTIME_H)




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2017 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2017 Sean Purcell
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2009 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"


	failure("%d", i);
	return (0);
}

static void
free_cpio_owner(struct cpio_owner *owner) {
	owner->uid = -1;
	owner->gid = -1;
	free(owner->uname);
	free(owner->gname);
}
#endif

DEFINE_TEST(test_owner_parse)

#if !defined(ROOT)
	skipping("No uid/gid configuration for this OS");
#else
	struct cpio_owner owner;
	const char *errstr;

	assert(0 == owner_parse(ROOT, &owner, &errstr));
	assert(int_in_list(owner.uid, root_uids,
		sizeof(root_uids)/sizeof(root_uids[0])));
	assertEqualInt(-1, owner.gid);
	free_cpio_owner(&owner);

	assert(0 == owner_parse(ROOT ":", &owner, &errstr));
	assert(int_in_list(owner.uid, root_uids,
		sizeof(root_uids)/sizeof(root_uids[0])));
	assert(int_in_list(owner.gid, root_gids,
		sizeof(root_gids)/sizeof(root_gids[0])));
	free_cpio_owner(&owner);

	assert(0 == owner_parse(ROOT ".", &owner, &errstr));
	assert(int_in_list(owner.uid, root_uids,
		sizeof(root_uids)/sizeof(root_uids[0])));
	assert(int_in_list(owner.gid, root_gids,
		sizeof(root_gids)/sizeof(root_gids[0])));
	free_cpio_owner(&owner);

	assert(0 == owner_parse("111", &owner, &errstr));
	assertEqualInt(111, owner.uid);
	assertEqualInt(-1, owner.gid);
	free_cpio_owner(&owner);

	assert(0 == owner_parse("112:", &owner, &errstr));
	assertEqualInt(112, owner.uid);
	/* Can't assert gid, since we don't know gid for user #112. */
	free_cpio_owner(&owner);

	assert(0 == owner_parse("113.", &owner, &errstr));
	assertEqualInt(113, owner.uid);
	/* Can't assert gid, since we don't know gid for user #113. */
	free_cpio_owner(&owner);

	assert(0 == owner_parse(":114", &owner, &errstr));
	assertEqualInt(-1, owner.uid);
	assertEqualInt(114, owner.gid);
	free_cpio_owner(&owner);

	assert(0 == owner_parse(".115", &owner, &errstr));
	assertEqualInt(-1, owner.uid);
	assertEqualInt(115, owner.gid);
	free_cpio_owner(&owner);

	assert(0 == owner_parse("116:117", &owner, &errstr));
	assertEqualInt(116, owner.uid);
	assertEqualInt(117, owner.gid);
	free_cpio_owner(&owner);

	/*
	 * TODO: Lookup current user/group name, build strings and

	 * users.
	 */

	errstr = NULL;
	assert(0 != owner_parse(":nonexistentgroup", &owner, &errstr));
	assertEqualString(errstr, "Couldn't lookup group ``nonexistentgroup''");
	free_cpio_owner(&owner);

	errstr = NULL;
	assert(0 != owner_parse(ROOT ":nonexistentgroup", &owner, &errstr));
	assertEqualString(errstr, "Couldn't lookup group ``nonexistentgroup''");
	free_cpio_owner(&owner);

	errstr = NULL;
	assert(0 != owner_parse("nonexistentuser:nonexistentgroup", &owner,
	    &errstr));
	assertEqualString(errstr, "Couldn't lookup user ``nonexistentuser''");
	free_cpio_owner(&owner);
#endif
}




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"


Lines 34-40 Link Here

(-)b/contrib/libarchive/libarchive/archive.h (-2 / +2 lines)
34	* assert that ARCHIVE_VERSION_NUMBER >= 2012108.	34	* assert that ARCHIVE_VERSION_NUMBER >= 2012108.
35	*/	35	*/
36	/* Note: Compiler will complain if this does not match archive_entry.h! */	36	/* Note: Compiler will complain if this does not match archive_entry.h! */
37	#define ARCHIVE_VERSION_NUMBER 3007004	37	#define ARCHIVE_VERSION_NUMBER 3007007
38		38
39	#include <sys/stat.h>	39	#include <sys/stat.h>
40	#include <stddef.h> /* for wchar_t */	40	#include <stddef.h> /* for wchar_t */
Lines 155-161 __LA_DECL int archive_version_number(void); Link Here
155	/*	155	/*
156	* Textual name/version of the library, useful for version displays.	156	* Textual name/version of the library, useful for version displays.
157	*/	157	*/
158	#define ARCHIVE_VERSION_ONLY_STRING "3.7.4"	158	#define ARCHIVE_VERSION_ONLY_STRING "3.7.7"
159	#define ARCHIVE_VERSION_STRING "libarchive " ARCHIVE_VERSION_ONLY_STRING	159	#define ARCHIVE_VERSION_STRING "libarchive " ARCHIVE_VERSION_ONLY_STRING
160	__LA_DECL const char * archive_version_string(void);	160	__LA_DECL const char * archive_version_string(void);
161		161




		    int type, int permset, int tag, int id, const char *name,
		    size_t len, struct archive_string_conv *sc);
static int	archive_acl_text_want_type(struct archive_acl *acl, int flags);
static size_t	archive_acl_text_len(struct archive_acl *acl, int want_type,
		    int flags, int wide, struct archive *a,
		    struct archive_string_conv *sc);
static int	isint_w(const wchar_t *start, const wchar_t *end, int *result);

		    int *result);
static int	is_nfs4_perms(const char *start, const char *end,
		    int *result);
static void	next_field(const char **p, size_t *l, const char **start,
		    const char **end, char *sep);
static void	append_entry(char **p, const char *prefix, int type,
		    int tag, int flags, const char *name, int perm, int id);

	}

	/* Add a new entry to the end of the list. */
	ap = calloc(1, sizeof(*ap));
	if (ap == NULL)
		return (NULL);
	if (aq == NULL)

/*
 * Calculate ACL text string length
 */
static size_t
archive_acl_text_len(struct archive_acl *acl, int want_type, int flags,
    int wide, struct archive *a, struct archive_string_conv *sc) {
	struct archive_acl_entry *ap;
	const char *name;
	const wchar_t *wname;
	int count, idlen, tmp, r;
	size_t length;
	size_t len;

	count = 0;

    struct archive *a)
{
	int count;
	size_t length;
	size_t len;
	const wchar_t *wname;
	const wchar_t *prefix;

		separator = L'\n';

	/* Now, allocate the string and actually populate it. */
	wp = ws = malloc(length * sizeof(*wp));
	if (wp == NULL) {
		if (errno == ENOMEM)
			__archive_errx(1, "No memory");


	len = wcslen(ws);

	if (len > length - 1)
		__archive_errx(1, "Buffer overrun");

	if (text_len != NULL)

    struct archive_string_conv *sc)
{
	int count;
	size_t length;
	size_t len;
	const char *name;
	const char *prefix;

		separator = '\n';

	/* Now, allocate the string and actually populate it. */
	p = s = malloc(length * sizeof(*p));
	if (p == NULL) {
		if (errno == ENOMEM)
			__archive_errx(1, "No memory");


	len = strlen(s);

	if (len > length - 1)
		__archive_errx(1, "Buffer overrun");

	if (text_len != NULL)

int
archive_acl_from_text_l(struct archive_acl *acl, const char *text,
    int want_type, struct archive_string_conv *sc)
{
	return archive_acl_from_text_nl(acl, text, strlen(text), want_type, sc);
}

int
archive_acl_from_text_nl(struct archive_acl *acl, const char *text,
    size_t length, int want_type, struct archive_string_conv *sc)
{
	struct {
		const char *start;

	ret = ARCHIVE_OK;
	types = 0;

	while (text != NULL && length > 0 && *text != '\0') {
		/*
		 * Parse the fields out of the next entry,
		 * advance 'text' to start of next entry.

		fields = 0;
		do {
			const char *start, *end;
			next_field(&text, &length, &start, &end, &sep);
			if (fields < numfields) {
				field[fields].start = start;
				field[fields].end = end;

}

/*
 * Match "[:whitespace:]*(.*)[:whitespace:]*[:,\n]".  *p is updated
 * to point to just after the separator.  *start points to the first
 * character of the matched text and *end just after the last
 * character of the matched identifier.  In particular *end - *start

 * whitespace.
 */
static void
next_field(const char **p, size_t *l, const char **start,
    const char **end, char *sep)
{
	/* Skip leading whitespace to find start of field. */
	while (*l > 0 && (**p == ' ' || **p == '\t' || **p == '\n')) {
		(*p)++;
		(*l)--;
	}
	*start = *p;

	/* Locate end of field, trim trailing whitespace if necessary */
	while (*l > 0 && **p != ' ' && **p != '\t' && **p != '\n' && **p != ',' && **p != ':' && **p != '#') {
	    **p != '#') {
		(*p)++;
		(*l)--;
	}
	*end = *p;

	/* Scan for the separator. */
	while (*l > 0 && **p != ',' && **p != ':' && **p != '\n' && **p != '#') {
		(*p)++;
		(*l)--;
		*end = *p - 1;
		while (**end == ' ' || **end == '\t' || **end == '\n') {
			(*end)--;
		}
		(*end)++;
	}
	*sep = **p;

	/* Handle in-field comments */
	if (*sep == '#') {
		while (*l > 0 && **p != ',' && **p != '\n') {
			(*p)++;
			(*l)--;
		}
		*sep = **p;
	}

	/* Skip separator. */
	if (*l > 0) {
		(*p)++;
		(*l)--;
	}
}

Lines 77-81 int archive_acl_from_text_w(struct archive_acl , const wchar_t /* wtext */, Link Here

(-)b/contrib/libarchive/libarchive/archive_acl_private.h (+2 lines)
77	int /* type */);	77	int /* type */);
78	int archive_acl_from_text_l(struct archive_acl , const char /* text */,	78	int archive_acl_from_text_l(struct archive_acl , const char /* text */,
79	int /* type /, struct archive_string_conv );	79	int /* type /, struct archive_string_conv );
		80	int archive_acl_from_text_nl(struct archive_acl , const char /* text */,
		81	size_t /* size of text /, int / type /, struct archive_string_conv );
80		82
81	#endif /* ARCHIVE_ENTRY_PRIVATE_H_INCLUDED */	83	#endif /* ARCHIVE_ENTRY_PRIVATE_H_INCLUDED */

Lines 30-35 Link Here

(-)b/contrib/libarchive/libarchive/archive_crc32.h (+5 lines)
30	#error This header is only to be used internally to libarchive.	30	#error This header is only to be used internally to libarchive.
31	#endif	31	#endif
32		32
		33	#include <stddef.h>
		34
33	/*	35	/*
34	* When zlib is unavailable, we should still be able to validate	36	* When zlib is unavailable, we should still be able to validate
35	* uncompressed zip archives. That requires us to be able to compute	37	* uncompressed zip archives. That requires us to be able to compute
Lines 46-51 crc32(unsigned long crc, const void *_p, size_t len) Link Here
46	static volatile int crc_tbl_inited = 0;	48	static volatile int crc_tbl_inited = 0;
47	static unsigned long crc_tbl[256];	49	static unsigned long crc_tbl[256];
48		50
		51	if (_p == NULL)
		52	return (0);
		53
49	if (!crc_tbl_inited) {	54	if (!crc_tbl_inited) {
50	for (b = 0; b < 256; ++b) {	55	for (b = 0; b < 256; ++b) {
51	crc2 = b;	56	crc2 = b;

Lines 57-63 pbkdf2_sha1(const char pw, size_t pw_len, const uint8_t salt, Link Here

(-)b/contrib/libarchive/libarchive/archive_cryptor.c (-2 / +2 lines)
57	return 0;	57	return 0;
58	}	58	}
59		59
60	#elif defined(_WIN32) && !defined(__CYGWIN__) && defined(HAVE_BCRYPT_H)	60	#elif defined(_WIN32) && !defined(__CYGWIN__) && defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
61	#ifdef _MSC_VER	61	#ifdef _MSC_VER
62	#pragma comment(lib, "Bcrypt.lib")	62	#pragma comment(lib, "Bcrypt.lib")
63	#endif	63	#endif
Lines 197-203 aes_ctr_release(archive_crypto_ctx *ctx) Link Here
197	return 0;	197	return 0;
198	}	198	}
199		199
200	#elif defined(_WIN32) && !defined(__CYGWIN__) && defined(HAVE_BCRYPT_H)	200	#elif defined(_WIN32) && !defined(__CYGWIN__) && defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
201		201
202	static int	202	static int
203	aes_ctr_init(archive_crypto_ctx ctx, const uint8_t key, size_t key_len)	203	aes_ctr_init(archive_crypto_ctx ctx, const uint8_t key, size_t key_len)

Lines 62-68 typedef struct { Link Here

(-)b/contrib/libarchive/libarchive/archive_cryptor_private.h (-1 / +1 lines)
62	unsigned encr_pos;	62	unsigned encr_pos;
63	} archive_crypto_ctx;	63	} archive_crypto_ctx;
64		64
65	#elif defined(_WIN32) && !defined(__CYGWIN__) && defined(HAVE_BCRYPT_H)	65	#elif defined(_WIN32) && !defined(__CYGWIN__) && defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
66	#include <bcrypt.h>	66	#include <bcrypt.h>
67		67
68	/* Common in other bcrypt implementations, but missing from VS2008. */	68	/* Common in other bcrypt implementations, but missing from VS2008. */




static char *	 ae_fflagstostr(unsigned long bitset, unsigned long bitclear);
static const wchar_t	*ae_wcstofflags(const wchar_t *stringp,
		    unsigned long *setp, unsigned long *clrp);
static const char	*ae_strtofflags(const char *stringp, size_t length,
		    unsigned long *setp, unsigned long *clrp);

#ifndef HAVE_WCSCPY

		return (NULL);
	archive_mstring_clean(&entry->ae_fflags_text);
	archive_mstring_clean(&entry->ae_gname);
	archive_mstring_clean(&entry->ae_linkname);
	archive_mstring_clean(&entry->ae_pathname);
	archive_mstring_clean(&entry->ae_sourcepath);
	archive_mstring_clean(&entry->ae_symlink);
	archive_mstring_clean(&entry->ae_uname);
	archive_entry_copy_mac_metadata(entry, NULL, 0);
	archive_acl_clear(&entry->acl);

	 * character sets are different? XXX */
	archive_mstring_copy(&entry2->ae_fflags_text, &entry->ae_fflags_text);
	archive_mstring_copy(&entry2->ae_gname, &entry->ae_gname);
	archive_mstring_copy(&entry2->ae_linkname, &entry->ae_linkname);
	archive_mstring_copy(&entry2->ae_pathname, &entry->ae_pathname);
	archive_mstring_copy(&entry2->ae_sourcepath, &entry->ae_sourcepath);
	archive_mstring_copy(&entry2->ae_symlink, &entry->ae_symlink);
	entry2->ae_set = entry->ae_set;
	archive_mstring_copy(&entry2->ae_uname, &entry->ae_uname);


{
	struct archive_entry *entry;

	entry = calloc(1, sizeof(*entry));
	if (entry == NULL)
		return (NULL);
	entry->archive = a;

	return (archive_mstring_get_mbs_l(entry->archive, &entry->ae_gname, p, len, sc));
}

void
archive_entry_set_link_to_hardlink(struct archive_entry *entry)
{
	if ((entry->ae_set & AE_SET_SYMLINK) != 0) {
		entry->ae_set &= ~AE_SET_SYMLINK;
	}
	entry->ae_set |= AE_SET_HARDLINK;
}

const char *
archive_entry_hardlink(struct archive_entry *entry)
{

	if ((entry->ae_set & AE_SET_HARDLINK) == 0)
		return (NULL);
	if (archive_mstring_get_mbs(
	    entry->archive, &entry->ae_linkname, &p) == 0)
		return (p);
	if (errno == ENOMEM)
		__archive_errx(1, "No memory");

	if ((entry->ae_set & AE_SET_HARDLINK) == 0)
		return (NULL);
	if (archive_mstring_get_utf8(
	    entry->archive, &entry->ae_linkname, &p) == 0)
		return (p);
	if (errno == ENOMEM)
		__archive_errx(1, "No memory");

	if ((entry->ae_set & AE_SET_HARDLINK) == 0)
		return (NULL);
	if (archive_mstring_get_wcs(
	    entry->archive, &entry->ae_linkname, &p) == 0)
		return (p);
	if (errno == ENOMEM)
		__archive_errx(1, "No memory");
	return (NULL);
}

int
archive_entry_hardlink_is_set(struct archive_entry *entry)
{
	return (entry->ae_set & AE_SET_HARDLINK) != 0;
}

int
_archive_entry_hardlink_l(struct archive_entry *entry,
    const char **p, size_t *len, struct archive_string_conv *sc)

		*len = 0;
		return (0);
	}
	return (archive_mstring_get_mbs_l(entry->archive, &entry->ae_linkname, p, len, sc));
}

la_int64_t

	return (entry->ae_set & AE_SET_PERM);
}

int
archive_entry_rdev_is_set(struct archive_entry *entry)
{
	return (entry->ae_set & AE_SET_RDEV);
}

dev_t
archive_entry_rdev(struct archive_entry *entry)
{
	if (archive_entry_rdev_is_set(entry)) {
		if (entry->ae_stat.aest_rdev_is_broken_down)
			return ae_makedev(entry->ae_stat.aest_rdevmajor,
			    entry->ae_stat.aest_rdevminor);
		else
			return (entry->ae_stat.aest_rdev);
	} else {
		return 0;
	}
}

dev_t
archive_entry_rdevmajor(struct archive_entry *entry)
{
	if (archive_entry_rdev_is_set(entry)) {
		if (entry->ae_stat.aest_rdev_is_broken_down)
			return (entry->ae_stat.aest_rdevmajor);
		else
			return major(entry->ae_stat.aest_rdev);
	} else {
		return 0;
	}
}

dev_t
archive_entry_rdevminor(struct archive_entry *entry)
{
	if (archive_entry_rdev_is_set(entry)) {
		if (entry->ae_stat.aest_rdev_is_broken_down)
			return (entry->ae_stat.aest_rdevminor);
		else
			return minor(entry->ae_stat.aest_rdev);
	} else {
		return 0;
	}
}

la_int64_t

	if ((entry->ae_set & AE_SET_SYMLINK) == 0)
		return (NULL);
	if (archive_mstring_get_mbs(
	    entry->archive, &entry->ae_linkname, &p) == 0)
		return (p);
	if (errno == ENOMEM)
		__archive_errx(1, "No memory");
	return (NULL);
}

void
archive_entry_set_link_to_symlink(struct archive_entry *entry)
{
	if ((entry->ae_set & AE_SET_HARDLINK) != 0) {
		entry->ae_set &= ~AE_SET_HARDLINK;
	}
	entry->ae_set |= AE_SET_SYMLINK;
}

int
archive_entry_symlink_type(struct archive_entry *entry)
{

	if ((entry->ae_set & AE_SET_SYMLINK) == 0)
		return (NULL);
	if (archive_mstring_get_utf8(
	    entry->archive, &entry->ae_linkname, &p) == 0)
		return (p);
	if (errno == ENOMEM)
		__archive_errx(1, "No memory");

	if ((entry->ae_set & AE_SET_SYMLINK) == 0)
		return (NULL);
	if (archive_mstring_get_wcs(
	    entry->archive, &entry->ae_linkname, &p) == 0)
		return (p);
	if (errno == ENOMEM)
		__archive_errx(1, "No memory");

		*len = 0;
		return (0);
	}
	return (archive_mstring_get_mbs_l(entry->archive, &entry->ae_linkname, p, len, sc));
}

la_int64_t


const char *
archive_entry_copy_fflags_text(struct archive_entry *entry,
	const char *flags)
{
	return archive_entry_copy_fflags_text_len(entry, flags, strlen(flags));
}

const char *
archive_entry_copy_fflags_text_len(struct archive_entry *entry,
    const char *flags, size_t flags_length)
{
	archive_mstring_copy_mbs_len(&entry->ae_fflags_text, flags, flags_length);
	return (ae_strtofflags(flags, flags_length,
		    &entry->ae_fflags_set, &entry->ae_fflags_clear));
}


void
archive_entry_set_gid(struct archive_entry *entry, la_int64_t g)
{
	if (g < 0) {
		g = 0;
	}
	entry->stat_valid = 0;
	entry->ae_stat.aest_gid = g;
	entry->ae_set |= AE_SET_GID;

void
archive_entry_set_ino(struct archive_entry *entry, la_int64_t ino)
{
	if (ino < 0) {
		ino = 0;
	}
	entry->stat_valid = 0;
	entry->ae_set |= AE_SET_INO;
	entry->ae_stat.aest_ino = ino;

void
archive_entry_set_ino64(struct archive_entry *entry, la_int64_t ino)
{
	if (ino < 0) {
		ino = 0;
	}
	entry->stat_valid = 0;
	entry->ae_set |= AE_SET_INO;
	entry->ae_stat.aest_ino = ino;

void
archive_entry_set_hardlink(struct archive_entry *entry, const char *target)
{
	if (target == NULL) {
	if (target != NULL)
		entry->ae_set |= AE_SET_HARDLINK;
	else
		entry->ae_set &= ~AE_SET_HARDLINK;
		if (entry->ae_set & AE_SET_SYMLINK) {
			return;
		}
	} else {
		entry->ae_set |= AE_SET_HARDLINK;
	}
	entry->ae_set &= ~AE_SET_SYMLINK;
	archive_mstring_copy_mbs(&entry->ae_linkname, target);
}

void
archive_entry_set_hardlink_utf8(struct archive_entry *entry, const char *target)
{
	if (target == NULL && (entry->ae_set & AE_SET_SYMLINK))
		return;
	archive_mstring_copy_utf8(&entry->ae_linkname, target);
	if (target != NULL)
		entry->ae_set |= AE_SET_HARDLINK;
	else

void
archive_entry_copy_hardlink(struct archive_entry *entry, const char *target)
{
	if (target == NULL && (entry->ae_set & AE_SET_SYMLINK))
		return;
	archive_mstring_copy_mbs(&entry->ae_linkname, target);
	if (target != NULL)
		entry->ae_set |= AE_SET_HARDLINK;
	else

void
archive_entry_copy_hardlink_w(struct archive_entry *entry, const wchar_t *target)
{
	if (target == NULL && (entry->ae_set & AE_SET_SYMLINK))
		return;
	archive_mstring_copy_wcs(&entry->ae_linkname, target);
	if (target != NULL)
		entry->ae_set |= AE_SET_HARDLINK;
	else

int
archive_entry_update_hardlink_utf8(struct archive_entry *entry, const char *target)
{
	if (target == NULL && (entry->ae_set & AE_SET_SYMLINK))
		return (0);
	if (target != NULL)
		entry->ae_set |= AE_SET_HARDLINK;
	else
		entry->ae_set &= ~AE_SET_HARDLINK;
	if (archive_mstring_update_utf8(entry->archive,
	    &entry->ae_linkname, target) == 0)
		return (1);
	if (errno == ENOMEM)
		__archive_errx(1, "No memory");

{
	int r;

	if (target == NULL && (entry->ae_set & AE_SET_SYMLINK))
		return (0);
	r = archive_mstring_copy_mbs_len_l(&entry->ae_linkname,
	    target, len, sc);
	if (target != NULL && r == 0)
		entry->ae_set |= AE_SET_HARDLINK;

void
archive_entry_set_link(struct archive_entry *entry, const char *target)
{
	archive_mstring_copy_mbs(&entry->ae_linkname, target);
	if ((entry->ae_set & AE_SET_SYMLINK) == 0) {
		entry->ae_set |= AE_SET_HARDLINK;
	}
}

void
archive_entry_set_link_utf8(struct archive_entry *entry, const char *target)
{
	archive_mstring_copy_utf8(&entry->ae_linkname, target);
	if ((entry->ae_set & AE_SET_SYMLINK) == 0) {
		entry->ae_set |= AE_SET_HARDLINK;
	}
}

/* Set symlink if symlink is already set, else set hardlink. */
void
archive_entry_copy_link(struct archive_entry *entry, const char *target)
{
	archive_mstring_copy_mbs(&entry->ae_linkname, target);
	if ((entry->ae_set & AE_SET_SYMLINK) == 0) {
		entry->ae_set |= AE_SET_HARDLINK;
	}
}

/* Set symlink if symlink is already set, else set hardlink. */
void
archive_entry_copy_link_w(struct archive_entry *entry, const wchar_t *target)
{
	archive_mstring_copy_wcs(&entry->ae_linkname, target);
	if ((entry->ae_set & AE_SET_SYMLINK) == 0) {
		entry->ae_set |= AE_SET_HARDLINK;
	}
}

int
archive_entry_update_link_utf8(struct archive_entry *entry, const char *target)
{
	int r;
	r = archive_mstring_update_utf8(entry->archive,
		    &entry->ae_linkname, target);
	if ((entry->ae_set & AE_SET_SYMLINK) == 0) {
		entry->ae_set |= AE_SET_HARDLINK;
	}
		    &entry->ae_hardlink, target);
	if (r == 0)
		return (1);
	if (errno == ENOMEM)

{
	int r;

	r = archive_mstring_copy_mbs_len_l(&entry->ae_linkname,
		r = archive_mstring_copy_mbs_len_l(&entry->ae_symlink,
		    target, len, sc);
	else
		r = archive_mstring_copy_mbs_len_l(&entry->ae_hardlink,
		    target, len, sc);
	if ((entry->ae_set & AE_SET_SYMLINK) == 0) {
		entry->ae_set |= AE_SET_HARDLINK;
	}
	return (r);
}


	entry->stat_valid = 0;
	entry->ae_stat.aest_rdev = m;
	entry->ae_stat.aest_rdev_is_broken_down = 0;
	entry->ae_stat.aest_rdevmajor = 0;
	entry->ae_stat.aest_rdevminor = 0;
	entry->ae_set |= AE_SET_RDEV;
}

void

{
	entry->stat_valid = 0;
	entry->ae_stat.aest_rdev_is_broken_down = 1;
	entry->ae_stat.aest_rdev = 0;
	entry->ae_stat.aest_rdevmajor = m;
	entry->ae_set |= AE_SET_RDEV;
}

void

{
	entry->stat_valid = 0;
	entry->ae_stat.aest_rdev_is_broken_down = 1;
	entry->ae_stat.aest_rdev = 0;
	entry->ae_stat.aest_rdevminor = m;
	entry->ae_set |= AE_SET_RDEV;
}

void
archive_entry_set_size(struct archive_entry *entry, la_int64_t s)
{
	if (s < 0) {
		s = 0;
	}
	entry->stat_valid = 0;
	entry->ae_stat.aest_size = s;
	entry->ae_set |= AE_SET_SIZE;

void
archive_entry_set_symlink(struct archive_entry *entry, const char *linkname)
{
	if (linkname == NULL && (entry->ae_set & AE_SET_HARDLINK))
		return;
	archive_mstring_copy_mbs(&entry->ae_linkname, linkname);
	entry->ae_set &= ~AE_SET_HARDLINK;
	if (linkname == NULL)
		entry->ae_set &= ~AE_SET_SYMLINK;
	else
		entry->ae_set |= AE_SET_SYMLINK;
}

void

void
archive_entry_set_symlink_utf8(struct archive_entry *entry, const char *linkname)
{
	if (linkname == NULL && (entry->ae_set & AE_SET_HARDLINK))
		return;
	archive_mstring_copy_utf8(&entry->ae_linkname, linkname);
	entry->ae_set &= ~AE_SET_HARDLINK;
	if (linkname == NULL)
		entry->ae_set &= ~AE_SET_SYMLINK;
	else
		entry->ae_set |= AE_SET_SYMLINK;
}

void
archive_entry_copy_symlink(struct archive_entry *entry, const char *linkname)
{
	if (linkname == NULL && (entry->ae_set & AE_SET_HARDLINK))
		return;
	archive_mstring_copy_mbs(&entry->ae_linkname, linkname);
	entry->ae_set &= ~AE_SET_HARDLINK;
	if (linkname == NULL)
		entry->ae_set &= ~AE_SET_SYMLINK;
	else
		entry->ae_set |= AE_SET_SYMLINK;
}

void
archive_entry_copy_symlink_w(struct archive_entry *entry, const wchar_t *linkname)
{
	if (linkname == NULL && (entry->ae_set & AE_SET_HARDLINK))
		return;
	archive_mstring_copy_wcs(&entry->ae_linkname, linkname);
	entry->ae_set &= ~AE_SET_HARDLINK;
	if (linkname == NULL)
		entry->ae_set &= ~AE_SET_SYMLINK;
	else
		entry->ae_set |= AE_SET_SYMLINK;
}

int
archive_entry_update_symlink_utf8(struct archive_entry *entry, const char *linkname)
{
	if (linkname == NULL && (entry->ae_set & AE_SET_HARDLINK))
		return (0);
	entry->ae_set &= ~AE_SET_HARDLINK;
	if (linkname == NULL)
		entry->ae_set &= ~AE_SET_SYMLINK;
	else
		entry->ae_set |= AE_SET_SYMLINK;
	if (archive_mstring_update_utf8(entry->archive,
	    &entry->ae_linkname, linkname) == 0)
		return (1);
	if (errno == ENOMEM)
		__archive_errx(1, "No memory");

{
	int r;

	if (linkname == NULL && (entry->ae_set & AE_SET_HARDLINK))
		return (0);
	entry->ae_set &= ~AE_SET_HARDLINK;
	r = archive_mstring_copy_mbs_len_l(&entry->ae_linkname,
	    linkname, len, sc);
	if (linkname == NULL || r != 0)
		entry->ae_set |= AE_SET_SYMLINK;
	else
		entry->ae_set &= ~AE_SET_SYMLINK;
	else
		entry->ae_set |= AE_SET_SYMLINK;
	return (r);
}

void
archive_entry_set_uid(struct archive_entry *entry, la_int64_t u)
{
	if (u < 0) {
		u = 0;
	}
	entry->stat_valid = 0;
	entry->ae_stat.aest_uid = u;
	entry->ae_set |= AE_SET_UID;


	if (length == 0)
		return (NULL);
	string = malloc(length);
	if (string == NULL)
		return (NULL);


 *	provided string.
 */
static const char *
ae_strtofflags(const char *s, size_t l, unsigned long *setp, unsigned long *clrp)
{
	const char *start, *end;
	const struct flag *flag;

	start = s;
	failed = NULL;
	/* Find start of first token. */
	while (l > 0 && (*start == '\t'  ||  *start == ' '  ||  *start == ',')) {
		start++;
		l--;
	}
	while (l > 0) {
		size_t length;
		/* Locate end of token. */
		end = start;
		while (l > 0 && *end != '\t'  &&
		    *end != ' '  &&  *end != ',') {
			end++;
			l--;
		}
		length = end - start;
		for (flag = fileflags; flag->name != NULL; flag++) {
			size_t flag_length = strlen(flag->name);


		/* Find start of next token. */
		start = end;
		while (l > 0 && (*start == '\t'  ||  *start == ' '  ||  *start == ',')) {
			start++;
			l--;
		}

	}





#define	ARCHIVE_ENTRY_H_INCLUDED

/* Note: Compiler will complain if this does not match archive.h! */
#define	ARCHIVE_VERSION_NUMBER 3007007

/*
 * Note: archive_entry.h is for use outside of libarchive; the

__LA_DECL const char	*archive_entry_gname(struct archive_entry *);
__LA_DECL const char	*archive_entry_gname_utf8(struct archive_entry *);
__LA_DECL const wchar_t	*archive_entry_gname_w(struct archive_entry *);
__LA_DECL void		 archive_entry_set_link_to_hardlink(struct archive_entry *);
__LA_DECL const char	*archive_entry_hardlink(struct archive_entry *);
__LA_DECL const char	*archive_entry_hardlink_utf8(struct archive_entry *);
__LA_DECL const wchar_t	*archive_entry_hardlink_w(struct archive_entry *);
__LA_DECL int		 archive_entry_hardlink_is_set(struct archive_entry *);
__LA_DECL la_int64_t	 archive_entry_ino(struct archive_entry *);
__LA_DECL la_int64_t	 archive_entry_ino64(struct archive_entry *);
__LA_DECL int		 archive_entry_ino_is_set(struct archive_entry *);

__LA_DECL const wchar_t	*archive_entry_pathname_w(struct archive_entry *);
__LA_DECL __LA_MODE_T	 archive_entry_perm(struct archive_entry *);
__LA_DECL int		 archive_entry_perm_is_set(struct archive_entry *);
__LA_DECL int		 archive_entry_rdev_is_set(struct archive_entry *);
__LA_DECL dev_t		 archive_entry_rdev(struct archive_entry *);
__LA_DECL dev_t		 archive_entry_rdevmajor(struct archive_entry *);
__LA_DECL dev_t		 archive_entry_rdevminor(struct archive_entry *);

__LA_DECL la_int64_t	 archive_entry_size(struct archive_entry *);
__LA_DECL int		 archive_entry_size_is_set(struct archive_entry *);
__LA_DECL const char	*archive_entry_strmode(struct archive_entry *);
__LA_DECL void		 archive_entry_set_link_to_symlink(struct archive_entry *);
__LA_DECL const char	*archive_entry_symlink(struct archive_entry *);
__LA_DECL const char	*archive_entry_symlink_utf8(struct archive_entry *);
__LA_DECL int		 archive_entry_symlink_type(struct archive_entry *);

/* Note that all recognized tokens are processed, regardless. */
__LA_DECL const char *archive_entry_copy_fflags_text(struct archive_entry *,
	    const char *);
__LA_DECL const char *archive_entry_copy_fflags_text_len(struct archive_entry *,
	    const char *, size_t);
__LA_DECL const wchar_t *archive_entry_copy_fflags_text_w(struct archive_entry *,
	    const wchar_t *);
__LA_DECL void	archive_entry_set_gid(struct archive_entry *, la_int64_t);

Lines 201-216 archive_entry_linkify(struct archive_entry_linkresolver *res, Link Here

(-)b/contrib/libarchive/libarchive/archive_entry_link_resolver.c (+15 lines)
201	le = find_entry(res, *e);	201	le = find_entry(res, *e);
202	if (le != NULL) {	202	if (le != NULL) {
203	archive_entry_unset_size(*e);	203	archive_entry_unset_size(*e);
		204	#if defined(_WIN32) && !defined(__CYGWIN__)
		205	archive_entry_copy_hardlink_w(*e,
		206	archive_entry_pathname_w(le->canonical));
		207	#else
204	archive_entry_copy_hardlink(*e,	208	archive_entry_copy_hardlink(*e,
205	archive_entry_pathname(le->canonical));	209	archive_entry_pathname(le->canonical));
		210	#endif
206	} else	211	} else
207	insert_entry(res, *e);	212	insert_entry(res, *e);
208	return;	213	return;
209	case ARCHIVE_ENTRY_LINKIFY_LIKE_MTREE:	214	case ARCHIVE_ENTRY_LINKIFY_LIKE_MTREE:
210	le = find_entry(res, *e);	215	le = find_entry(res, *e);
211	if (le != NULL) {	216	if (le != NULL) {
		217	#if defined(_WIN32) && !defined(__CYGWIN__)
		218	archive_entry_copy_hardlink_w(*e,
		219	archive_entry_pathname_w(le->canonical));
		220	#else
212	archive_entry_copy_hardlink(*e,	221	archive_entry_copy_hardlink(*e,
213	archive_entry_pathname(le->canonical));	222	archive_entry_pathname(le->canonical));
		223	#endif
214	} else	224	} else
215	insert_entry(res, *e);	225	insert_entry(res, *e);
216	return;	226	return;
Lines 229-236 archive_entry_linkify(struct archive_entry_linkresolver *res, Link Here
229	le->entry = t;	239	le->entry = t;
230	/* Make the old entry into a hardlink. */	240	/* Make the old entry into a hardlink. */
231	archive_entry_unset_size(*e);	241	archive_entry_unset_size(*e);
		242	#if defined(_WIN32) && !defined(__CYGWIN__)
		243	archive_entry_copy_hardlink_w(*e,
		244	archive_entry_pathname_w(le->canonical));
		245	#else
232	archive_entry_copy_hardlink(*e,	246	archive_entry_copy_hardlink(*e,
233	archive_entry_pathname(le->canonical));	247	archive_entry_pathname(le->canonical));
		248	#endif
234	/* If we ran out of links, return the	249	/* If we ran out of links, return the
235	* final entry as well. */	250	* final entry as well. */
236	if (le->links == 0) {	251	if (le->links == 0) {

Lines 150-155 character strings at the same time. Link Here

(-)b/contrib/libarchive/libarchive/archive_entry_perms.3 (+1 lines)
150	.Fn archive_entry_set_XXX	150	.Fn archive_entry_set_XXX
151	is an alias for	151	is an alias for
152	.Fn archive_entry_copy_XXX .	152	.Fn archive_entry_copy_XXX .
		153	The strings are copied, and don't need to outlive the call.
153	.Ss File Flags	154	.Ss File Flags
154	File flags are transparently converted between a bitmap	155	File flags are transparently converted between a bitmap
155	representation and a textual format.	156	representation and a textual format.




#define	AE_SET_FILETYPE	1024
#define	AE_SET_UID	2048
#define	AE_SET_GID	4096
#define	AE_SET_RDEV	8192

	/*
	 * Use aes here so that we get transparent mbs<->wcs conversions.

	unsigned long ae_fflags_set;		/* Bitmap fflags */
	unsigned long ae_fflags_clear;
	struct archive_mstring ae_gname;		/* Name of owning group */
	struct archive_mstring ae_linkname;	/* Name of target for hardlink or symlink */
	struct archive_mstring ae_pathname;	/* Name of entry */
	struct archive_mstring ae_symlink;		/* symlink contents */
	struct archive_mstring ae_uname;		/* Name of owner */

	/* Not used within libarchive; useful for some clients. */

Lines 76-82 archive_entry_sparse_add_entry(struct archive_entry *entry, Link Here

(-)b/contrib/libarchive/libarchive/archive_entry_sparse.c (-1 / +1 lines)
76	}	76	}
77	}	77	}
78		78
79	if ((sp = (struct ae_sparse )malloc(sizeof(sp))) == NULL)	79	if ((sp = malloc(sizeof(*sp))) == NULL)
80	/* XXX Error XXX */	80	/* XXX Error XXX */
81	return;	81	return;
82		82

Lines 90-96 archive_entry_xattr_add_entry(struct archive_entry *entry, Link Here

(-)b/contrib/libarchive/libarchive/archive_entry_xattr.c (-1 / +1 lines)
90	{	90	{
91	struct ae_xattr *xp;	91	struct ae_xattr *xp;
92		92
93	if ((xp = (struct ae_xattr *)malloc(sizeof(struct ae_xattr))) == NULL)	93	if ((xp = malloc(sizeof(struct ae_xattr))) == NULL)
94	__archive_errx(1, "Out of memory");	94	__archive_errx(1, "Out of memory");
95		95
96	if ((xp->name = strdup(name)) == NULL)	96	if ((xp->name = strdup(name)) == NULL)

Lines 74-80 __hmac_sha1_cleanup(archive_hmac_sha1_ctx *ctx) Link Here

(-)b/contrib/libarchive/libarchive/archive_hmac.c (-1 / +1 lines)
74	memset(ctx, 0, sizeof(*ctx));	74	memset(ctx, 0, sizeof(*ctx));
75	}	75	}
76		76
77	#elif defined(_WIN32) && !defined(__CYGWIN__) && defined(HAVE_BCRYPT_H)	77	#elif defined(_WIN32) && !defined(__CYGWIN__) && defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
78		78
79	#ifndef BCRYPT_HASH_REUSABLE_FLAG	79	#ifndef BCRYPT_HASH_REUSABLE_FLAG
80	# define BCRYPT_HASH_REUSABLE_FLAG 0x00000020	80	# define BCRYPT_HASH_REUSABLE_FLAG 0x00000020

Lines 52-58 int __libarchive_hmac_build_hack(void); Link Here

(-)b/contrib/libarchive/libarchive/archive_hmac_private.h (-1 / +1 lines)
52		52
53	typedef CCHmacContext archive_hmac_sha1_ctx;	53	typedef CCHmacContext archive_hmac_sha1_ctx;
54		54
55	#elif defined(_WIN32) && !defined(__CYGWIN__) && defined(HAVE_BCRYPT_H)	55	#elif defined(_WIN32) && !defined(__CYGWIN__) && defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
56	#include <bcrypt.h>	56	#include <bcrypt.h>
57		57
58	typedef struct {	58	typedef struct {

Lines 220-226 archive_match_new(void) Link Here

(-)b/contrib/libarchive/libarchive/archive_match.c (-1 / +1 lines)
220	{	220	{
221	struct archive_match *a;	221	struct archive_match *a;
222		222
223	a = (struct archive_match )calloc(1, sizeof(a));	223	a = calloc(1, sizeof(*a));
224	if (a == NULL)	224	if (a == NULL)
225	return (NULL);	225	return (NULL);
226	a->archive.magic = ARCHIVE_MATCH_MAGIC;	226	a->archive.magic = ARCHIVE_MATCH_MAGIC;

Lines 39-45 Link Here

(-)b/contrib/libarchive/libarchive/archive_openssl_evp_private.h (-1 / +1 lines)
39	#include <string.h> /* memset */	39	#include <string.h> /* memset */
40	static inline EVP_MD_CTX *EVP_MD_CTX_new(void)	40	static inline EVP_MD_CTX *EVP_MD_CTX_new(void)
41	{	41	{
42	EVP_MD_CTX ctx = (EVP_MD_CTX )calloc(1, sizeof(EVP_MD_CTX));	42	EVP_MD_CTX *ctx = calloc(1, sizeof(EVP_MD_CTX));
43	return ctx;	43	return ctx;
44	}	44	}
45		45

Lines 39-45 Link Here

(-)b/contrib/libarchive/libarchive/archive_openssl_hmac_private.h (-1 / +1 lines)
39	#include <string.h> /* memset */	39	#include <string.h> /* memset */
40	static inline HMAC_CTX *HMAC_CTX_new(void)	40	static inline HMAC_CTX *HMAC_CTX_new(void)
41	{	41	{
42	HMAC_CTX ctx = (HMAC_CTX )calloc(1, sizeof(HMAC_CTX));	42	HMAC_CTX *ctx = calloc(1, sizeof(HMAC_CTX));
43	return ctx;	43	return ctx;
44	}	44	}
45		45

Lines 138-144 static Bool Ppmd7_Alloc(CPpmd7 *p, UInt32 size) Link Here

(-)b/contrib/libarchive/libarchive/archive_ppmd7.c (-1 / +1 lines)
138	#else	138	#else
139	4 - (size & 3);	139	4 - (size & 3);
140	#endif	140	#endif
141	if ((p->Base = (Byte *)malloc(p->AlignOffset + size	141	if ((p->Base = malloc(p->AlignOffset + size
142	#ifndef PPMD_32BIT	142	#ifndef PPMD_32BIT
143	+ UNIT_SIZE	143	+ UNIT_SIZE
144	#endif	144	#endif




      #else
        4 - (size & 3);
      #endif
    if ((p->Base = malloc(p->AlignOffset + size)) == 0)
      return False;
    p->Size = size;
  }

    upState.Freq = (Byte)(1 + ((2 * cf <= s0) ? (5 * cf > s0) : ((cf + 2 * s0 - 3) / s0)));
  }

  while (numPs != 0)
  {
    /* Create Child */
    CTX_PTR c1; /* = AllocContext(p); */

    SetSuccessor(ps[--numPs], REF(c1));
    c = c1;
  }

  
  return c;
}





#define ARCHIVE_PRIVATE_H_INCLUDED

#ifndef __LIBARCHIVE_BUILD
#ifndef __LIBARCHIVE_TEST
#error This header is only to be used internally to libarchive.
#endif
#endif

#if HAVE_ICONV_H
#include <iconv.h>

void	__archive_ensure_cloexec_flag(int fd);
int	__archive_mktemp(const char *tmpdir);
#if defined(_WIN32) && !defined(__CYGWIN__)
int	__archive_mkstemp(wchar_t *templates);
#else
int	__archive_mkstemp(char *templates);
#endif

int	__archive_clean(struct archive *);




{
	struct archive_read *a;

	a = calloc(1, sizeof(*a));
	if (a == NULL)
		return (NULL);
	a->archive.magic = ARCHIVE_READ_MAGIC;

		}

		filter
		    = calloc(1, sizeof(*filter));
		if (filter == NULL)
			return (ARCHIVE_FATAL);
		filter->bidder = best_bidder;

		if (filter->client_avail <= 0) {
			if (filter->end_of_file) {
				if (avail != NULL)
					*avail = filter->avail;
				return (NULL);
			}
			bytes_read = (filter->vtable->read)(filter,

					s = t;
				}
				/* Now s >= min, so allocate a new buffer. */
				p = malloc(s);
				if (p == NULL) {
					archive_set_error(
						&filter->archive->archive,




    number_bidders = sizeof(a->bidders) / sizeof(a->bidders[0]);

    bidder = a->bidders;
    for (i = 1; i < number_bidders; i++, bidder++)
    {
      if (!bidder->name || !strcmp(bidder->name, str))
        break;

      return (ARCHIVE_FATAL);
    }

    filter = calloc(1, sizeof(*filter));
        = (struct archive_read_filter *)calloc(1, sizeof(*filter));
    if (filter == NULL)
    {
      archive_set_error(&a->archive, ENOMEM, "Out of memory");

    return (ARCHIVE_FATAL);
  }

  filter = calloc(1, sizeof(*filter));
      = (struct archive_read_filter *)calloc(1, sizeof(*filter));
  if (filter == NULL)
  {
    archive_set_error(&a->archive, ENOMEM, "Out of memory");

Lines 520-525 setup_xattr(struct archive_read_disk *a, Link Here

(-)b/contrib/libarchive/libarchive/archive_read_disk_entry_from_file.c (+1 lines)
520	if (size == -1) {	520	if (size == -1) {
521	archive_set_error(&a->archive, errno,	521	archive_set_error(&a->archive, errno,
522	"Couldn't read extended attribute");	522	"Couldn't read extended attribute");
		523	free(value);
523	return (ARCHIVE_WARN);	524	return (ARCHIVE_WARN);
524	}	525	}
525		526

Lines 451-457 archive_read_disk_new(void) Link Here

(-)b/contrib/libarchive/libarchive/archive_read_disk_posix.c (-1 / +1 lines)
451	{	451	{
452	struct archive_read_disk *a;	452	struct archive_read_disk *a;
453		453
454	a = (struct archive_read_disk )calloc(1, sizeof(a));	454	a = calloc(1, sizeof(*a));
455	if (a == NULL)	455	if (a == NULL)
456	return (NULL);	456	return (NULL);
457	a->archive.magic = ARCHIVE_READ_DISK_MAGIC;	457	a->archive.magic = ARCHIVE_READ_DISK_MAGIC;

Lines 51-57 struct archive_read_extract * Link Here

(-)b/contrib/libarchive/libarchive/archive_read_extract2.c (-1 / +1 lines)
51	__archive_read_get_extract(struct archive_read *a)	51	__archive_read_get_extract(struct archive_read *a)
52	{	52	{
53	if (a->extract == NULL) {	53	if (a->extract == NULL) {
54	a->extract = (struct archive_read_extract )calloc(1, sizeof(a->extract));	54	a->extract = calloc(1, sizeof(*a->extract));
55	if (a->extract == NULL) {	55	if (a->extract == NULL) {
56	archive_set_error(&a->archive, ENOMEM, "Can't extract");	56	archive_set_error(&a->archive, ENOMEM, "Can't extract");
57	return (NULL);	57	return (NULL);

Lines 74-80 archive_read_open_fd(struct archive *a, int fd, size_t block_size) Link Here

(-)b/contrib/libarchive/libarchive/archive_read_open_fd.c (-1 / +1 lines)
74	return (ARCHIVE_FATAL);	74	return (ARCHIVE_FATAL);
75	}	75	}
76		76
77	mine = (struct read_fd_data )calloc(1, sizeof(mine));	77	mine = calloc(1, sizeof(*mine));
78	b = malloc(block_size);	78	b = malloc(block_size);
79	if (mine == NULL \|\| b == NULL) {	79	if (mine == NULL \|\| b == NULL) {
80	archive_set_error(a, ENOMEM, "No memory");	80	archive_set_error(a, ENOMEM, "No memory");

Lines 69-75 archive_read_open_FILE(struct archive a, FILE f) Link Here

(-)b/contrib/libarchive/libarchive/archive_read_open_file.c (-1 / +1 lines)
69	void *b;	69	void *b;
70		70
71	archive_clear_error(a);	71	archive_clear_error(a);
72	mine = (struct read_FILE_data )malloc(sizeof(mine));	72	mine = malloc(sizeof(*mine));
73	b = malloc(block_size);	73	b = malloc(block_size);
74	if (mine == NULL \|\| b == NULL) {	74	if (mine == NULL \|\| b == NULL) {
75	archive_set_error(a, ENOMEM, "No memory");	75	archive_set_error(a, ENOMEM, "No memory");

Lines 122-128 archive_read_open_filenames(struct archive a, const char *filenames, Link Here

(-)b/contrib/libarchive/libarchive/archive_read_open_filename.c (-2 / +2 lines)
122	{	122	{
123	if (filename == NULL)	123	if (filename == NULL)
124	filename = "";	124	filename = "";
125	mine = (struct read_file_data *)calloc(1,	125	mine = calloc(1,
126	sizeof(*mine) + strlen(filename));	126	sizeof(*mine) + strlen(filename));
127	if (mine == NULL)	127	if (mine == NULL)
128	goto no_memory;	128	goto no_memory;
Lines 175-181 archive_read_open_filenames_w(struct archive a, const wchar_t *wfilenames, Link Here
175	{	175	{
176	if (wfilename == NULL)	176	if (wfilename == NULL)
177	wfilename = L"";	177	wfilename = L"";
178	mine = (struct read_file_data *)calloc(1,	178	mine = calloc(1,
179	sizeof(mine) + wcslen(wfilename) sizeof(wchar_t));	179	sizeof(mine) + wcslen(wfilename) sizeof(wchar_t));
180	if (mine == NULL)	180	if (mine == NULL)
181	goto no_memory;	181	goto no_memory;

Lines 69-75 archive_read_open_memory2(struct archive a, const void buff, Link Here

(-)b/contrib/libarchive/libarchive/archive_read_open_memory.c (-1 / +1 lines)
69	{	69	{
70	struct read_memory_data *mine;	70	struct read_memory_data *mine;
71		71
72	mine = (struct read_memory_data )calloc(1, sizeof(mine));	72	mine = calloc(1, sizeof(*mine));
73	if (mine == NULL) {	73	if (mine == NULL) {
74	archive_set_error(a, ENOMEM, "No memory");	74	archive_set_error(a, ENOMEM, "No memory");
75	return (ARCHIVE_FATAL);	75	return (ARCHIVE_FATAL);

Lines 190-197 bzip2_reader_init(struct archive_read_filter *self) Link Here

(-)b/contrib/libarchive/libarchive/archive_read_support_filter_bzip2.c (-2 / +2 lines)
190	self->code = ARCHIVE_FILTER_BZIP2;	190	self->code = ARCHIVE_FILTER_BZIP2;
191	self->name = "bzip2";	191	self->name = "bzip2";
192		192
193	state = (struct private_data )calloc(1, sizeof(state));	193	state = calloc(1, sizeof(*state));
194	out_block = (unsigned char *)malloc(out_block_size);	194	out_block = malloc(out_block_size);
195	if (state == NULL \|\| out_block == NULL) {	195	if (state == NULL \|\| out_block == NULL) {
196	archive_set_error(&self->archive->archive, ENOMEM,	196	archive_set_error(&self->archive->archive, ENOMEM,
197	"Can't allocate data for bzip2 decompression");	197	"Can't allocate data for bzip2 decompression");

Lines 217-223 compress_bidder_init(struct archive_read_filter *self) Link Here

(-)b/contrib/libarchive/libarchive/archive_read_support_filter_compress.c (-1 / +1 lines)
217	self->code = ARCHIVE_FILTER_COMPRESS;	217	self->code = ARCHIVE_FILTER_COMPRESS;
218	self->name = "compress (.Z)";	218	self->name = "compress (.Z)";
219		219
220	state = (struct private_data )calloc(1, sizeof(state));	220	state = calloc(1, sizeof(*state));
221	out_block = malloc(out_block_size);	221	out_block = malloc(out_block_size);
222	if (state == NULL \|\| out_block == NULL) {	222	if (state == NULL \|\| out_block == NULL) {
223	free(out_block);	223	free(out_block);

Lines 123-128 archive_read_support_filter_gzip(struct archive *_a) Link Here

(-)b/contrib/libarchive/libarchive/archive_read_support_filter_gzip.c (-4 / +14 lines)
123	* number of bytes in header. If pbits is non-NULL, it receives a	123	* number of bytes in header. If pbits is non-NULL, it receives a
124	* count of bits verified, suitable for use by bidder.	124	* count of bits verified, suitable for use by bidder.
125	*/	125	*/
		126	#define MAX_FILENAME_LENGTH (1024 * 1024L)
		127	#define MAX_COMMENT_LENGTH (1024 * 1024L)
126	static ssize_t	128	static ssize_t
127	peek_at_header(struct archive_read_filter filter, int pbits,	129	peek_at_header(struct archive_read_filter filter, int pbits,
128	#ifdef HAVE_ZLIB_H	130	#ifdef HAVE_ZLIB_H
Lines 180-188 peek_at_header(struct archive_read_filter filter, int pbits, Link Here
180	#endif	182	#endif
181	do {	183	do {
182	++len;	184	++len;
183	if (avail < len)	185	if (avail < len) {
		186	if (avail > MAX_FILENAME_LENGTH) {
		187	return (0);
		188	}
184	p = __archive_read_filter_ahead(filter,	189	p = __archive_read_filter_ahead(filter,
185	len, &avail);	190	len, &avail);
		191	}
186	if (p == NULL)	192	if (p == NULL)
187	return (0);	193	return (0);
188	} while (p[len - 1] != 0);	194	} while (p[len - 1] != 0);
Lines 200-208 peek_at_header(struct archive_read_filter filter, int pbits, Link Here
200	if (header_flags & 16) {	206	if (header_flags & 16) {
201	do {	207	do {
202	++len;	208	++len;
203	if (avail < len)	209	if (avail < len) {
		210	if (avail > MAX_COMMENT_LENGTH) {
		211	return (0);
		212	}
204	p = __archive_read_filter_ahead(filter,	213	p = __archive_read_filter_ahead(filter,
205	len, &avail);	214	len, &avail);
		215	}
206	if (p == NULL)	216	if (p == NULL)
207	return (0);	217	return (0);
208	} while (p[len - 1] != 0);	218	} while (p[len - 1] != 0);
Lines 307-314 gzip_bidder_init(struct archive_read_filter *self) Link Here
307	self->code = ARCHIVE_FILTER_GZIP;	317	self->code = ARCHIVE_FILTER_GZIP;
308	self->name = "gzip";	318	self->name = "gzip";
309		319
310	state = (struct private_data )calloc(1, sizeof(state));	320	state = calloc(1, sizeof(*state));
311	out_block = (unsigned char *)malloc(out_block_size);	321	out_block = malloc(out_block_size);
312	if (state == NULL \|\| out_block == NULL) {	322	if (state == NULL \|\| out_block == NULL) {
313	free(out_block);	323	free(out_block);
314	free(state);	324	free(state);




	self->code = ARCHIVE_FILTER_LZ4;
	self->name = "lz4";

	state = calloc(1, sizeof(*state));
	if (state == NULL) {
		archive_set_error(&self->archive->archive, ENOMEM,
		    "Can't allocate data for lz4 decompression");

		out_block_size += 64 * 1024;
	if (state->out_block_size < out_block_size) {
		free(state->out_block);
		out_block = malloc(out_block_size);
		state->out_block_size = out_block_size;
		if (out_block == NULL) {
			archive_set_error(&self->archive->archive, ENOMEM,


	if (state->out_block_size < out_block_size) {
		free(state->out_block);
		out_block = malloc(out_block_size);
		state->out_block_size = out_block_size;
		if (out_block == NULL) {
			archive_set_error(&self->archive->archive, ENOMEM,

Lines 185-191 lzop_bidder_init(struct archive_read_filter *self) Link Here

(-)b/contrib/libarchive/libarchive/archive_read_support_filter_lzop.c (-2 / +3 lines)
185	self->code = ARCHIVE_FILTER_LZOP;	185	self->code = ARCHIVE_FILTER_LZOP;
186	self->name = "lzop";	186	self->name = "lzop";
187		187
188	state = (struct read_lzop )calloc(1, sizeof(state));	188	state = calloc(1, sizeof(*state));
189	if (state == NULL) {	189	if (state == NULL) {
190	archive_set_error(&self->archive->archive, ENOMEM,	190	archive_set_error(&self->archive->archive, ENOMEM,
191	"Can't allocate data for lzop decompression");	191	"Can't allocate data for lzop decompression");
Lines 291-297 consume_header(struct archive_read_filter *self) Link Here
291	if (p == NULL)	291	if (p == NULL)
292	goto truncated;	292	goto truncated;
293	len = archive_be32dec(p);	293	len = archive_be32dec(p);
294	__archive_read_filter_consume(self->upstream, len + 4 + 4);	294	__archive_read_filter_consume(self->upstream,
		295	(int64_t)len + 4 + 4);
295	}	296	}
296	state->flags = flags;	297	state->flags = flags;
297	state->in_stream = 1;	298	state->in_stream = 1;

Lines 139-145 archive_read_support_filter_program_signature(struct archive *_a, Link Here

(-)b/contrib/libarchive/libarchive/archive_read_support_filter_program.c (-3 / +3 lines)
139	/*	139	/*
140	* Allocate our private state.	140	* Allocate our private state.
141	*/	141	*/
142	state = (struct program_bidder )calloc(1, sizeof (state));	142	state = calloc(1, sizeof (*state));
143	if (state == NULL)	143	if (state == NULL)
144	goto memerr;	144	goto memerr;
145	state->cmd = strdup(cmd);	145	state->cmd = strdup(cmd);
Lines 398-405 __archive_read_program(struct archive_read_filter self, const char cmd) Link Here
398	size_t l;	398	size_t l;
399		399
400	l = strlen(prefix) + strlen(cmd) + 1;	400	l = strlen(prefix) + strlen(cmd) + 1;
401	state = (struct program_filter )calloc(1, sizeof(state));	401	state = calloc(1, sizeof(*state));
402	out_buf = (char *)malloc(out_buf_len);	402	out_buf = malloc(out_buf_len);
403	if (state == NULL \|\| out_buf == NULL \|\|	403	if (state == NULL \|\| out_buf == NULL \|\|
404	archive_string_ensure(&state->description, l) == NULL) {	404	archive_string_ensure(&state->description, l) == NULL) {
405	archive_set_error(&self->archive->archive, ENOMEM,	405	archive_set_error(&self->archive->archive, ENOMEM,

Lines 39-46 Link Here

(-)b/contrib/libarchive/libarchive/archive_read_support_filter_rpm.c (-19 / +26 lines)
39		39
40	struct rpm {	40	struct rpm {
41	int64_t total_in;	41	int64_t total_in;
42	size_t hpos;	42	uint64_t hpos;
43	size_t hlen;	43	uint64_t hlen;
44	unsigned char header[16];	44	unsigned char header[16];
45	enum {	45	enum {
46	ST_LEAD, /* Skipping 'Lead' section. */	46	ST_LEAD, /* Skipping 'Lead' section. */
Lines 53-59 struct rpm { Link Here
53	} state;	53	} state;
54	int first_header;	54	int first_header;
55	};	55	};
56	#define RPM_LEAD_SIZE 96 /* Size of 'Lead' section. */	56	#define RPM_LEAD_SIZE 96 /* Size of 'Lead' section. */
		57	#define RPM_MIN_HEAD_SIZE 16 /* Minimum size of 'Head'. */
57		58
58	static int rpm_bidder_bid(struct archive_read_filter_bidder *,	59	static int rpm_bidder_bid(struct archive_read_filter_bidder *,
59	struct archive_read_filter *);	60	struct archive_read_filter *);
Lines 63-68 static ssize_t rpm_filter_read(struct archive_read_filter *, Link Here
63	const void **);	64	const void **);
64	static int rpm_filter_close(struct archive_read_filter *);	65	static int rpm_filter_close(struct archive_read_filter *);
65		66
		67	static inline size_t rpm_limit_bytes(uint64_t, size_t);
		68
66	#if ARCHIVE_VERSION_NUMBER < 4000000	69	#if ARCHIVE_VERSION_NUMBER < 4000000
67	/* Deprecated; remove in libarchive 4.0 */	70	/* Deprecated; remove in libarchive 4.0 */
68	int	71	int
Lines 141-147 rpm_bidder_init(struct archive_read_filter *self) Link Here
141	self->code = ARCHIVE_FILTER_RPM;	144	self->code = ARCHIVE_FILTER_RPM;
142	self->name = "rpm";	145	self->name = "rpm";
143		146
144	rpm = (struct rpm )calloc(1, sizeof(rpm));	147	rpm = calloc(1, sizeof(*rpm));
145	if (rpm == NULL) {	148	if (rpm == NULL) {
146	archive_set_error(&self->archive->archive, ENOMEM,	149	archive_set_error(&self->archive->archive, ENOMEM,
147	"Can't allocate data for rpm");	150	"Can't allocate data for rpm");
Lines 155-169 rpm_bidder_init(struct archive_read_filter *self) Link Here
155	return (ARCHIVE_OK);	158	return (ARCHIVE_OK);
156	}	159	}
157		160
		161	static inline size_t
		162	rpm_limit_bytes(uint64_t bytes, size_t max)
		163	{
		164	return (bytes > max ? max : (size_t)bytes);
		165	}
		166
158	static ssize_t	167	static ssize_t
159	rpm_filter_read(struct archive_read_filter self, const void *buff)	168	rpm_filter_read(struct archive_read_filter self, const void *buff)
160	{	169	{
161	struct rpm *rpm;	170	struct rpm *rpm;
162	const unsigned char *b;	171	const unsigned char *b;
163	ssize_t avail_in, total;	172	ssize_t avail_in, total, used;
164	size_t used, n;	173	size_t n;
165	uint32_t section;	174	uint64_t section;
166	uint32_t bytes;	175	uint64_t bytes;
167		176
168	rpm = (struct rpm *)self->data;	177	rpm = (struct rpm *)self->data;
169	*buff = NULL;	178	*buff = NULL;
Lines 197-211 rpm_filter_read(struct archive_read_filter self, const void *buff) Link Here
197	}	206	}
198	break;	207	break;
199	case ST_HEADER:	208	case ST_HEADER:
200	n = 16 - rpm->hpos;	209	n = rpm_limit_bytes(RPM_MIN_HEAD_SIZE - rpm->hpos,
201	if (n > avail_in - used)	210	avail_in - used);
202	n = avail_in - used;
203	memcpy(rpm->header+rpm->hpos, b, n);	211	memcpy(rpm->header+rpm->hpos, b, n);
204	b += n;	212	b += n;
205	used += n;	213	used += n;
206	rpm->hpos += n;	214	rpm->hpos += n;
207		215
208	if (rpm->hpos == 16) {	216	if (rpm->hpos == RPM_MIN_HEAD_SIZE) {
209	if (rpm->header[0] != 0x8e \|\|	217	if (rpm->header[0] != 0x8e \|\|
210	rpm->header[1] != 0xad \|\|	218	rpm->header[1] != 0xad \|\|
211	rpm->header[2] != 0xe8 \|\|	219	rpm->header[2] != 0xe8 \|\|
Lines 219-239 rpm_filter_read(struct archive_read_filter self, const void *buff) Link Here
219	}	227	}
220	rpm->state = ST_ARCHIVE;	228	rpm->state = ST_ARCHIVE;
221	*buff = rpm->header;	229	*buff = rpm->header;
222	total = rpm->hpos;	230	total = RPM_MIN_HEAD_SIZE;
223	break;	231	break;
224	}	232	}
225	/* Calculate 'Header' length. */	233	/* Calculate 'Header' length. */
226	section = archive_be32dec(rpm->header+8);	234	section = archive_be32dec(rpm->header+8);
227	bytes = archive_be32dec(rpm->header+12);	235	bytes = archive_be32dec(rpm->header+12);
228	rpm->hlen = 16 + section * 16 + bytes;	236	rpm->hlen = rpm->hpos + section * 16 + bytes;
229	rpm->state = ST_HEADER_DATA;	237	rpm->state = ST_HEADER_DATA;
230	rpm->first_header = 0;	238	rpm->first_header = 0;
231	}	239	}
232	break;	240	break;
233	case ST_HEADER_DATA:	241	case ST_HEADER_DATA:
234	n = rpm->hlen - rpm->hpos;	242	n = rpm_limit_bytes(rpm->hlen - rpm->hpos,
235	if (n > avail_in - used)	243	avail_in - used);
236	n = avail_in - used;
237	b += n;	244	b += n;
238	used += n;	245	used += n;
239	rpm->hpos += n;	246	rpm->hpos += n;
Lines 241-247 rpm_filter_read(struct archive_read_filter self, const void *buff) Link Here
241	rpm->state = ST_PADDING;	248	rpm->state = ST_PADDING;
242	break;	249	break;
243	case ST_PADDING:	250	case ST_PADDING:
244	while (used < (size_t)avail_in) {	251	while (used < avail_in) {
245	if (*b != 0) {	252	if (*b != 0) {
246	/* Read next header. */	253	/* Read next header. */
247	rpm->state = ST_HEADER;	254	rpm->state = ST_HEADER;
Lines 259-265 rpm_filter_read(struct archive_read_filter self, const void *buff) Link Here
259	used = avail_in;	266	used = avail_in;
260	break;	267	break;
261	}	268	}
262	if (used == (size_t)avail_in) {	269	if (used == avail_in) {
263	rpm->total_in += used;	270	rpm->total_in += used;
264	__archive_read_filter_consume(self->upstream, used);	271	__archive_read_filter_consume(self->upstream, used);
265	b = NULL;	272	b = NULL;

Lines 43-53 Link Here

(-)b/contrib/libarchive/libarchive/archive_read_support_filter_uu.c (-4 / +12 lines)
43	/* Maximum lookahead during bid phase */	43	/* Maximum lookahead during bid phase */
44	#define UUENCODE_BID_MAX_READ 1281024 / in bytes */	44	#define UUENCODE_BID_MAX_READ 1281024 / in bytes */
45		45
		46	#define UUENCODE_MAX_LINE_LENGTH 341024 / in bytes */
		47
46	struct uudecode {	48	struct uudecode {
47	int64_t total;	49	int64_t total;
48	unsigned char *in_buff;	50	unsigned char *in_buff;
49	#define IN_BUFF_SIZE (1024)	51	#define IN_BUFF_SIZE (1024)
50	int in_cnt;	52	ssize_t in_cnt;
51	size_t in_allocated;	53	size_t in_allocated;
52	unsigned char *out_buff;	54	unsigned char *out_buff;
53	#define OUT_BUFF_SIZE (64 * 1024)	55	#define OUT_BUFF_SIZE (64 * 1024)
Lines 373-379 uudecode_bidder_init(struct archive_read_filter *self) Link Here
373	self->code = ARCHIVE_FILTER_UU;	375	self->code = ARCHIVE_FILTER_UU;
374	self->name = "uu";	376	self->name = "uu";
375		377
376	uudecode = (struct uudecode )calloc(1, sizeof(uudecode));	378	uudecode = calloc(1, sizeof(*uudecode));
377	out_buff = malloc(OUT_BUFF_SIZE);	379	out_buff = malloc(OUT_BUFF_SIZE);
378	in_buff = malloc(IN_BUFF_SIZE);	380	in_buff = malloc(IN_BUFF_SIZE);
379	if (uudecode == NULL \|\| out_buff == NULL \|\| in_buff == NULL) {	381	if (uudecode == NULL \|\| out_buff == NULL \|\| in_buff == NULL) {
Lines 484-489 uudecode_filter_read(struct archive_read_filter self, const void *buff) Link Here
484	goto finish;	486	goto finish;
485	}	487	}
486	if (uudecode->in_cnt) {	488	if (uudecode->in_cnt) {
		489	if (uudecode->in_cnt > UUENCODE_MAX_LINE_LENGTH) {
		490	archive_set_error(&self->archive->archive,
		491	ARCHIVE_ERRNO_FILE_FORMAT,
		492	"Invalid format data");
		493	return (ARCHIVE_FATAL);
		494	}
487	/*	495	/*
488	* If there is remaining data which is saved by	496	* If there is remaining data which is saved by
489	* previous calling, use it first.	497	* previous calling, use it first.
Lines 498-504 uudecode_filter_read(struct archive_read_filter self, const void *buff) Link Here
498	uudecode->in_cnt = 0;	506	uudecode->in_cnt = 0;
499	}	507	}
500	for (;used < avail_in; d += llen, used += llen) {	508	for (;used < avail_in; d += llen, used += llen) {
501	int64_t l, body;	509	ssize_t l, body;
502		510
503	b = d;	511	b = d;
504	len = get_line(b, avail_in - used, &nl);	512	len = get_line(b, avail_in - used, &nl);
Lines 533-539 uudecode_filter_read(struct archive_read_filter self, const void *buff) Link Here
533	return (ARCHIVE_FATAL);	541	return (ARCHIVE_FATAL);
534	if (uudecode->in_buff != b)	542	if (uudecode->in_buff != b)
535	memmove(uudecode->in_buff, b, len);	543	memmove(uudecode->in_buff, b, len);
536	uudecode->in_cnt = (int)len;	544	uudecode->in_cnt = len;
537	if (total == 0) {	545	if (total == 0) {
538	/* Do not return 0; it means end-of-file.	546	/* Do not return 0; it means end-of-file.
539	* We should try to read bytes more. */	547	* We should try to read bytes more. */

Lines 476-483 xz_lzma_bidder_init(struct archive_read_filter *self) Link Here

(-)b/contrib/libarchive/libarchive/archive_read_support_filter_xz.c (-2 / +2 lines)
476	struct private_data *state;	476	struct private_data *state;
477	int ret;	477	int ret;
478		478
479	state = (struct private_data )calloc(1, sizeof(state));	479	state = calloc(1, sizeof(*state));
480	out_block = (unsigned char *)malloc(out_block_size);	480	out_block = malloc(out_block_size);
481	if (state == NULL \|\| out_block == NULL) {	481	if (state == NULL \|\| out_block == NULL) {
482	archive_set_error(&self->archive->archive, ENOMEM,	482	archive_set_error(&self->archive->archive, ENOMEM,
483	"Can't allocate data for xz decompression");	483	"Can't allocate data for xz decompression");

Lines 175-182 zstd_bidder_init(struct archive_read_filter *self) Link Here

(-)b/contrib/libarchive/libarchive/archive_read_support_filter_zstd.c (-2 / +2 lines)
175	self->code = ARCHIVE_FILTER_ZSTD;	175	self->code = ARCHIVE_FILTER_ZSTD;
176	self->name = "zstd";	176	self->name = "zstd";
177		177
178	state = (struct private_data )calloc(1, sizeof(state));	178	state = calloc(1, sizeof(*state));
179	out_block = (unsigned char *)malloc(out_block_size);	179	out_block = malloc(out_block_size);
180	dstream = ZSTD_createDStream();	180	dstream = ZSTD_createDStream();
181		181
182	if (state == NULL \|\| out_block == NULL \|\| dstream == NULL) {	182	if (state == NULL \|\| out_block == NULL \|\| dstream == NULL) {





	if (zip_entry->attr & supported_attrs) {
		char *fflags_text, *ptr;
		/* allocate for ",rdonly,hidden,system" */
		fflags_text = malloc(22 * sizeof(*fflags_text));
		if (fflags_text != NULL) {
			ptr = fflags_text; 
			if (zip_entry->attr & FILE_ATTRIBUTE_READONLY) {
				strcpy(ptr, ",rdonly");
				ptr = ptr + 7;
			}
			if (zip_entry->attr & FILE_ATTRIBUTE_HIDDEN) {
				strcpy(ptr, ",hidden");
				ptr = ptr + 7;
			}
			if (zip_entry->attr & FILE_ATTRIBUTE_SYSTEM) {
				strcpy(ptr, ",system");
				ptr = ptr + 7;
			}
			if (ptr > fflags_text) {
				archive_entry_copy_fflags_text(entry,
				    fflags_text + 1);
			}
			free(fflags_text);
 		} 
 		free(fflags_text); 
		}
	}


			zip_entry->mode |= AE_IFREG;
			archive_entry_set_mode(entry, zip_entry->mode);
		} else {
			struct archive_string_conv* utf8_conv;

			symname[symsize] = '\0';

			/* Symbolic links are embedded as UTF-8 strings */
			utf8_conv = archive_string_conversion_from_charset(&a->archive,
			    "UTF-8", 1);
			if (utf8_conv == NULL) {
				free(symname);
				return ARCHIVE_FATAL;
			}

			archive_entry_copy_symlink_l(entry, (const char*)symname, symsize,
			    utf8_conv);
		}
		free(symname);
		archive_entry_set_size(entry, 0);

	if (zip->end_of_entry)
		return (ARCHIVE_EOF);

	size_t bytes_to_read = 16 * 1024 * 1024;  // Don't try to read more than 16 MB at a time
	size_t bytes_to_read = max_read_size;
	if ((uint64_t)bytes_to_read > zip->entry_bytes_remaining) {
		bytes_to_read = (size_t)zip->entry_bytes_remaining;
	}
	bytes = read_stream(a, buff, bytes_to_read, 0);
	if (bytes < 0)

		 */
		ssize_t bytes_avail = 0;
		const uint8_t* data = __archive_read_ahead(a,
		    (size_t)zip->ppstream.stream_in+1, &bytes_avail);
		if(data == NULL || bytes_avail < zip->ppstream.stream_in+1) {
			archive_set_error(&a->archive,
			    ARCHIVE_ERRNO_FILE_FORMAT,
			    "Truncated 7z file data");

		}
		zip->stream_valid = 0;
	}
#endif
#ifdef HAVE_ZSTD_H
	if (zip->zstdstream_valid)
		ZSTD_freeDStream(zip->zstd_dstream);
#endif
	if (zip->ppmd7_valid) {
		__archive_ppmd7_functions.Ppmd7_Free(

	usizes = ss->unpackSizes;
	for (i = 0; i < numFolders; i++) {
		unsigned pack;
		uint64_t size, sum;

		if (f[i].numUnpackStreams == 0)
			continue;

			for (pack = 1; pack < f[i].numUnpackStreams; pack++) {
				if (parse_7zip_uint64(a, usizes) < 0)
					return (-1);
				if (*usizes > UINT64_MAX - sum)
					return (-1);
				sum += *usizes++;
			}
		}
		size = folder_uncompressed_size(&f[i]);
		if (size < sum)
			return (-1);
		*usizes++ = size - sum;
	}

	if (type == kSize) {

		packPos = si->pi.pos;
		for (i = 0; i < si->pi.numPackStreams; i++) {
			si->pi.positions[i] = packPos;
			if (packPos > UINT64_MAX - si->pi.sizes[i])
				return (-1);
			packPos += si->pi.sizes[i];
			if (packPos > zip->header_offset)
				return (-1);

		f = si->ci.folders;
		for (i = 0; i < si->ci.numFolders; i++) {
			f[i].packIndex = packIndex;
			if (f[i].numPackedStreams > UINT32_MAX)
				return (-1);
			if (packIndex > UINT32_MAX - (uint32_t)f[i].numPackedStreams)
				return (-1);
			packIndex += (uint32_t)f[i].numPackedStreams;
			if (packIndex > si->pi.numPackStreams)
				return (-1);

	/* CRC check. */
	if (crc32(0, (const unsigned char *)p + 12, 20)
	    != archive_le32dec(p + 8)) {
#ifndef DONT_FAIL_ON_CRC_ERROR
		archive_set_error(&a->archive, -1, "Header CRC error");
		return (ARCHIVE_FATAL);
#endif

		/* Copy mode. */

		*buff = __archive_read_ahead(a, minimum, &bytes_avail);
		if (*buff == NULL) {
			archive_set_error(&a->archive,
			    ARCHIVE_ERRNO_FILE_FORMAT,
			    "Truncated 7-Zip file data");

	/*
	 * Skip the bytes we already has skipped in skip_stream().
	 */
	while (1) {
		ssize_t skipped;

		if (zip->uncompressed_buffer_bytes_remaining == 0) {

				return (ARCHIVE_FATAL);
			}
		}

		if (!skip_bytes)
			break;

		skipped = get_uncompressed_data(
			a, buff, (size_t)skip_bytes, 0);
		if (skipped < 0)




	archive_check_magic(_a, ARCHIVE_READ_MAGIC,
	    ARCHIVE_STATE_NEW, "archive_read_support_format_ar");

	ar = calloc(1, sizeof(*ar));
	if (ar == NULL) {
		archive_set_error(&a->archive, ENOMEM,
		    "Can't allocate ar data");

			return (ARCHIVE_FATAL);
		}
		/* Store it in the entry. */
		p = malloc(bsd_name_length + 1);
		if (p == NULL) {
			archive_set_error(&a->archive, ENOMEM,
			    "Can't allocate fname buffer");

	if ((header_data = __archive_read_ahead(a, 60, NULL)) == NULL)
		/* Broken header. */
		return (ARCHIVE_EOF);

	unconsumed = 60;

	ret = _ar_read_header(a, entry, ar, (const char *)header_data, &unconsumed);

	if (unconsumed)

	uint64_t n;

	/* Copy remaining header */
	archive_entry_set_filetype(entry, AE_IFREG);
	archive_entry_set_mtime(entry,
	    (time_t)ar_atol10(h + AR_date_offset, AR_date_size), 0L);
	archive_entry_set_uid(entry,

	    (gid_t)ar_atol10(h + AR_gid_offset, AR_gid_size));
	archive_entry_set_mode(entry,
	    (mode_t)ar_atol8(h + AR_mode_offset, AR_mode_size));
	archive_entry_set_filetype(entry, AE_IFREG);
	n = ar_atol10(h + AR_size_offset, AR_size_size);

	ar->entry_offset = 0;




	archive_check_magic(_a, ARCHIVE_READ_MAGIC,
	    ARCHIVE_STATE_NEW, "archive_read_support_format_cab");

	cab = calloc(1, sizeof(*cab));
	if (cab == NULL) {
		archive_set_error(&a->archive, ENOMEM,
		    "Can't allocate CAB data");

	/*
	 * Read CFFOLDER.
	 */
	hd->folder_array = calloc(
	    hd->folder_count, sizeof(struct cffolder));
	if (hd->folder_array == NULL)
		goto nomem;

		cab->cab_offset += skip;
	}
	/* Allocate memory for CFDATA */
	hd->file_array = calloc(
	    hd->file_count, sizeof(struct cffile));
	if (hd->file_array == NULL)
		goto nomem;

	if (cab->uncompressed_buffer == NULL) {
		cab->uncompressed_buffer_size = 0x8000;
		cab->uncompressed_buffer
		    = malloc(cab->uncompressed_buffer_size);
		if (cab->uncompressed_buffer == NULL) {
			archive_set_error(&a->archive, ENOMEM,
			    "No memory for CAB reader");

	if (cab->uncompressed_buffer == NULL) {
		cab->uncompressed_buffer_size = 0x8000;
		cab->uncompressed_buffer
		    = malloc(cab->uncompressed_buffer_size);
		if (cab->uncompressed_buffer == NULL) {
			archive_set_error(&a->archive, ENOMEM,
			    "No memory for CAB reader");

		    cfdata->uncompressed_size - cab->xstrm.total_out;

		d = __archive_read_ahead(a, 1, &bytes_avail);
		if (d == NULL) {
			archive_set_error(&a->archive,
			    ARCHIVE_ERRNO_FILE_FORMAT,
			    "Truncated CAB file data");

Lines 228-234 archive_read_support_format_cpio(struct archive *_a) Link Here

(-)b/contrib/libarchive/libarchive/archive_read_support_format_cpio.c (-11 / +21 lines)
228	archive_check_magic(_a, ARCHIVE_READ_MAGIC,	228	archive_check_magic(_a, ARCHIVE_READ_MAGIC,
229	ARCHIVE_STATE_NEW, "archive_read_support_format_cpio");	229	ARCHIVE_STATE_NEW, "archive_read_support_format_cpio");
230		230
231	cpio = (struct cpio )calloc(1, sizeof(cpio));	231	cpio = calloc(1, sizeof(*cpio));
232	if (cpio == NULL) {	232	if (cpio == NULL) {
233	archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data");	233	archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data");
234	return (ARCHIVE_FATAL);	234	return (ARCHIVE_FATAL);
Lines 834-839 static int Link Here
834	header_afiol(struct archive_read a, struct cpio cpio,	834	header_afiol(struct archive_read a, struct cpio cpio,
835	struct archive_entry entry, size_t namelength, size_t *name_pad)	835	struct archive_entry entry, size_t namelength, size_t *name_pad)
836	{	836	{
		837	int64_t t;
837	const void *h;	838	const void *h;
838	const char *header;	839	const char *header;
839		840
Lines 850-856 header_afiol(struct archive_read a, struct cpio cpio, Link Here
850		851
851	archive_entry_set_dev(entry,	852	archive_entry_set_dev(entry,
852	(dev_t)atol16(header + afiol_dev_offset, afiol_dev_size));	853	(dev_t)atol16(header + afiol_dev_offset, afiol_dev_size));
853	archive_entry_set_ino(entry, atol16(header + afiol_ino_offset, afiol_ino_size));	854	t = atol16(header + afiol_ino_offset, afiol_ino_size);
		855	if (t < 0) {
		856	archive_set_error(&a->archive, 0, "Nonsensical ino value");
		857	return (ARCHIVE_FATAL);
		858	}
		859	archive_entry_set_ino(entry, t);
854	archive_entry_set_mode(entry,	860	archive_entry_set_mode(entry,
855	(mode_t)atol8(header + afiol_mode_offset, afiol_mode_size));	861	(mode_t)atol8(header + afiol_mode_offset, afiol_mode_size));
856	archive_entry_set_uid(entry, atol16(header + afiol_uid_offset, afiol_uid_size));	862	archive_entry_set_uid(entry, atol16(header + afiol_uid_offset, afiol_uid_size));
Lines 863-870 header_afiol(struct archive_read a, struct cpio cpio, Link Here
863	*namelength = (size_t)atol16(header + afiol_namesize_offset, afiol_namesize_size);	869	*namelength = (size_t)atol16(header + afiol_namesize_offset, afiol_namesize_size);
864	name_pad = 0; / No padding of filename. */	870	name_pad = 0; / No padding of filename. */
865		871
866	cpio->entry_bytes_remaining =	872	t = atol16(header + afiol_filesize_offset, afiol_filesize_size);
867	atol16(header + afiol_filesize_offset, afiol_filesize_size);	873	if (t < 0) {
		874	archive_set_error(&a->archive, 0, "Nonsensical file size");
		875	return (ARCHIVE_FATAL);
		876	}
		877	cpio->entry_bytes_remaining = t;
868	archive_entry_set_size(entry, cpio->entry_bytes_remaining);	878	archive_entry_set_size(entry, cpio->entry_bytes_remaining);
869	cpio->entry_padding = 0;	879	cpio->entry_padding = 0;
870	__archive_read_consume(a, afiol_header_size);	880	__archive_read_consume(a, afiol_header_size);
Lines 1002-1008 be4(const unsigned char *p) Link Here
1002	static int64_t	1012	static int64_t
1003	atol8(const char *p, unsigned char_cnt)	1013	atol8(const char *p, unsigned char_cnt)
1004	{	1014	{
1005	int64_t l;	1015	uint64_t l;
1006	int digit;	1016	int digit;
1007		1017
1008	l = 0;	1018	l = 0;
Lines 1010-1027 atol8(const char *p, unsigned char_cnt) Link Here
1010	if (p >= '0' && p <= '7')	1020	if (p >= '0' && p <= '7')
1011	digit = *p - '0';	1021	digit = *p - '0';
1012	else	1022	else
1013	return (l);	1023	return ((int64_t)l);
1014	p++;	1024	p++;
1015	l <<= 3;	1025	l <<= 3;
1016	l \|= digit;	1026	l \|= digit;
1017	}	1027	}
1018	return (l);	1028	return ((int64_t)l);
1019	}	1029	}
1020		1030
1021	static int64_t	1031	static int64_t
1022	atol16(const char *p, unsigned char_cnt)	1032	atol16(const char *p, unsigned char_cnt)
1023	{	1033	{
1024	int64_t l;	1034	uint64_t l;
1025	int digit;	1035	int digit;
1026		1036
1027	l = 0;	1037	l = 0;
Lines 1033-1044 atol16(const char *p, unsigned char_cnt) Link Here
1033	else if (p >= '0' && p <= '9')	1043	else if (p >= '0' && p <= '9')
1034	digit = *p - '0';	1044	digit = *p - '0';
1035	else	1045	else
1036	return (l);	1046	return ((int64_t)l);
1037	p++;	1047	p++;
1038	l <<= 4;	1048	l <<= 4;
1039	l \|= digit;	1049	l \|= digit;
1040	}	1050	}
1041	return (l);	1051	return ((int64_t)l);
1042	}	1052	}
1043		1053
1044	static int	1054	static int
Lines 1078-1084 record_hardlink(struct archive_read *a, Link Here
1078	}	1088	}
1079	}	1089	}
1080		1090
1081	le = (struct links_entry *)malloc(sizeof(struct links_entry));	1091	le = malloc(sizeof(struct links_entry));
1082	if (le == NULL) {	1092	if (le == NULL) {
1083	archive_set_error(&a->archive,	1093	archive_set_error(&a->archive,
1084	ENOMEM, "Out of memory adding file to list");	1094	ENOMEM, "Out of memory adding file to list");

Lines 273-279 struct file_info { Link Here

(-)b/contrib/libarchive/libarchive/archive_read_support_format_iso9660.c (-27 / +278 lines)
273	char re; /* Having RRIP "RE" extension. */	273	char re; /* Having RRIP "RE" extension. */
274	char re_descendant;	274	char re_descendant;
275	uint64_t cl_offset; /* Having RRIP "CL" extension. */	275	uint64_t cl_offset; /* Having RRIP "CL" extension. */
276	int birthtime_is_set;	276	int time_is_set; /* Bitmask indicating which times are known */
277	time_t birthtime; /* File created time. */	277	time_t birthtime; /* File created time. */
278	time_t mtime; /* File last modified time. */	278	time_t mtime; /* File last modified time. */
279	time_t atime; /* File last accessed time. */	279	time_t atime; /* File last accessed time. */
Lines 306-311 struct file_info { Link Here
306	} rede_files;	306	} rede_files;
307	};	307	};
308		308
		309	#define BIRTHTIME_IS_SET 1
		310	#define MTIME_IS_SET 2
		311	#define ATIME_IS_SET 4
		312	#define CTIME_IS_SET 8
		313
309	struct heap_queue {	314	struct heap_queue {
310	struct file_info **files;	315	struct file_info **files;
311	int allocated;	316	int allocated;
Lines 394-400 static void dump_isodirrec(FILE , const unsigned char isodirrec); Link Here
394	#endif	399	#endif
395	static time_t time_from_tm(struct tm *);	400	static time_t time_from_tm(struct tm *);
396	static time_t isodate17(const unsigned char *);	401	static time_t isodate17(const unsigned char *);
		402	static int isodate17_valid(const unsigned char *);
397	static time_t isodate7(const unsigned char *);	403	static time_t isodate7(const unsigned char *);
		404	static int isodate7_valid(const unsigned char *);
398	static int isBootRecord(struct iso9660 , const unsigned char );	405	static int isBootRecord(struct iso9660 , const unsigned char );
399	static int isVolumePartition(struct iso9660 , const unsigned char );	406	static int isVolumePartition(struct iso9660 , const unsigned char );
400	static int isVDSetTerminator(struct iso9660 , const unsigned char );	407	static int isVDSetTerminator(struct iso9660 , const unsigned char );
Lines 402-407 static int isJolietSVD(struct iso9660 , const unsigned char ); Link Here
402	static int isSVD(struct iso9660 , const unsigned char );	409	static int isSVD(struct iso9660 , const unsigned char );
403	static int isEVD(struct iso9660 , const unsigned char );	410	static int isEVD(struct iso9660 , const unsigned char );
404	static int isPVD(struct iso9660 , const unsigned char );	411	static int isPVD(struct iso9660 , const unsigned char );
		412	static int isRootDirectoryRecord(const unsigned char *);
		413	static int isValid723Integer(const unsigned char *);
		414	static int isValid733Integer(const unsigned char *);
405	static int next_cache_entry(struct archive_read , struct iso9660 ,	415	static int next_cache_entry(struct archive_read , struct iso9660 ,
406	struct file_info **);	416	struct file_info **);
407	static int next_entry_seek(struct archive_read , struct iso9660 ,	417	static int next_entry_seek(struct archive_read , struct iso9660 ,
Lines 453-459 archive_read_support_format_iso9660(struct archive *_a) Link Here
453	archive_check_magic(_a, ARCHIVE_READ_MAGIC,	463	archive_check_magic(_a, ARCHIVE_READ_MAGIC,
454	ARCHIVE_STATE_NEW, "archive_read_support_format_iso9660");	464	ARCHIVE_STATE_NEW, "archive_read_support_format_iso9660");
455		465
456	iso9660 = (struct iso9660 )calloc(1, sizeof(iso9660));	466	iso9660 = calloc(1, sizeof(*iso9660));
457	if (iso9660 == NULL) {	467	if (iso9660 == NULL) {
458	archive_set_error(&a->archive, ENOMEM,	468	archive_set_error(&a->archive, ENOMEM,
459	"Can't allocate iso9660 data");	469	"Can't allocate iso9660 data");
Lines 773-780 isSVD(struct iso9660 iso9660, const unsigned char h) Link Here
773		783
774	/* Read Root Directory Record in Volume Descriptor. */	784	/* Read Root Directory Record in Volume Descriptor. */
775	p = h + SVD_root_directory_record_offset;	785	p = h + SVD_root_directory_record_offset;
776	if (p[DR_length_offset] != 34)	786	if (!isRootDirectoryRecord(p)) {
777	return (0);	787	return (0);
		788	}
778		789
779	return (48);	790	return (48);
780	}	791	}
Lines 851-858 isEVD(struct iso9660 iso9660, const unsigned char h) Link Here
851		862
852	/* Read Root Directory Record in Volume Descriptor. */	863	/* Read Root Directory Record in Volume Descriptor. */
853	p = h + PVD_root_directory_record_offset;	864	p = h + PVD_root_directory_record_offset;
854	if (p[DR_length_offset] != 34)	865	if (!isRootDirectoryRecord(p)) {
855	return (0);	866	return (0);
		867	}
856		868
857	return (48);	869	return (48);
858	}	870	}
Lines 882-902 isPVD(struct iso9660 iso9660, const unsigned char h) Link Here
882	if (!isNull(iso9660, h, PVD_reserved2_offset, PVD_reserved2_size))	894	if (!isNull(iso9660, h, PVD_reserved2_offset, PVD_reserved2_size))
883	return (0);	895	return (0);
884		896
		897	/* Volume space size must be encoded according to 7.3.3 */
		898	if (!isValid733Integer(h + PVD_volume_space_size_offset)) {
		899	return (0);
		900	}
		901	volume_block = archive_le32dec(h + PVD_volume_space_size_offset);
		902	if (volume_block <= SYSTEM_AREA_BLOCK+4)
		903	return (0);
		904
885	/* Reserved field must be 0. */	905	/* Reserved field must be 0. */
886	if (!isNull(iso9660, h, PVD_reserved3_offset, PVD_reserved3_size))	906	if (!isNull(iso9660, h, PVD_reserved3_offset, PVD_reserved3_size))
887	return (0);	907	return (0);
888		908
		909	/* Volume set size must be encoded according to 7.2.3 */
		910	if (!isValid723Integer(h + PVD_volume_set_size_offset)) {
		911	return (0);
		912	}
		913
		914	/* Volume sequence number must be encoded according to 7.2.3 */
		915	if (!isValid723Integer(h + PVD_volume_sequence_number_offset)) {
		916	return (0);
		917	}
		918
889	/* Logical block size must be > 0. */	919	/* Logical block size must be > 0. */
890	/* I've looked at Ecma 119 and can't find any stronger	920	/* I've looked at Ecma 119 and can't find any stronger
891	* restriction on this field. */	921	* restriction on this field. */
		922	if (!isValid723Integer(h + PVD_logical_block_size_offset)) {
		923	return (0);
		924	}
892	logical_block_size =	925	logical_block_size =
893	archive_le16dec(h + PVD_logical_block_size_offset);	926	archive_le16dec(h + PVD_logical_block_size_offset);
894	if (logical_block_size <= 0)	927	if (logical_block_size <= 0)
895	return (0);	928	return (0);
896		929
897	volume_block = archive_le32dec(h + PVD_volume_space_size_offset);	930	/* Path Table size must be encoded according to 7.3.3 */
898	if (volume_block <= SYSTEM_AREA_BLOCK+4)	931	if (!isValid733Integer(h + PVD_path_table_size_offset)) {
899	return (0);	932	return (0);
		933	}
900		934
901	/* File structure version must be 1 for ISO9660/ECMA119. */	935	/* File structure version must be 1 for ISO9660/ECMA119. */
902	if (h[PVD_file_structure_version_offset] != 1)	936	if (h[PVD_file_structure_version_offset] != 1)
Lines 935-942 isPVD(struct iso9660 iso9660, const unsigned char h) Link Here
935		969
936	/* Read Root Directory Record in Volume Descriptor. */	970	/* Read Root Directory Record in Volume Descriptor. */
937	p = h + PVD_root_directory_record_offset;	971	p = h + PVD_root_directory_record_offset;
938	if (p[DR_length_offset] != 34)	972	if (!isRootDirectoryRecord(p)) {
939	return (0);	973	return (0);
		974	}
940		975
941	if (!iso9660->primary.location) {	976	if (!iso9660->primary.location) {
942	iso9660->logical_block_size = logical_block_size;	977	iso9660->logical_block_size = logical_block_size;
Lines 951-956 isPVD(struct iso9660 iso9660, const unsigned char h) Link Here
951	return (48);	986	return (48);
952	}	987	}
953		988
		989	static int
		990	isRootDirectoryRecord(const unsigned char *p) {
		991	int flags;
		992
		993	/* ECMA119/ISO9660 requires that the root directory record be _exactly_ 34 bytes.
		994	* However, we've seen images that have root directory records up to 68 bytes. */
		995	if (p[DR_length_offset] < 34 \|\| p[DR_length_offset] > 68) {
		996	return (0);
		997	}
		998
		999	/* The root directory location must be a 7.3.3 32-bit integer. */
		1000	if (!isValid733Integer(p + DR_extent_offset)) {
		1001	return (0);
		1002	}
		1003
		1004	/* The root directory size must be a 7.3.3 integer. */
		1005	if (!isValid733Integer(p + DR_size_offset)) {
		1006	return (0);
		1007	}
		1008
		1009	/* According to the standard, certain bits must be one or zero:
		1010	* Bit 1: must be 1 (this is a directory)
		1011	* Bit 2: must be 0 (not an associated file)
		1012	* Bit 3: must be 0 (doesn't use extended attribute record)
		1013	* Bit 7: must be 0 (final directory record for this file)
		1014	*/
		1015	flags = p[DR_flags_offset];
		1016	if ((flags & 0x8E) != 0x02) {
		1017	return (0);
		1018	}
		1019
		1020	/* Volume sequence number must be a 7.2.3 integer. */
		1021	if (!isValid723Integer(p + DR_volume_sequence_number_offset)) {
		1022	return (0);
		1023	}
		1024
		1025	/* Root directory name is a single zero byte... */
		1026	if (p[DR_name_len_offset] != 1 \|\| p[DR_name_offset] != 0) {
		1027	return (0);
		1028	}
		1029
		1030	/* Nothing looked wrong, so let's accept it. */
		1031	return (1);
		1032	}
		1033
954	static int	1034	static int
955	read_children(struct archive_read a, struct file_info parent)	1035	read_children(struct archive_read a, struct file_info parent)
956	{	1036	{
Lines 1212-1218 archive_read_format_iso9660_read_header(struct archive_read *a, Link Here
1212	}	1292	}
1213	}	1293	}
1214	if (iso9660->utf16be_previous_path == NULL) {	1294	if (iso9660->utf16be_previous_path == NULL) {
1215	iso9660->utf16be_previous_path = malloc(UTF16_NAME_MAX);	1295	iso9660->utf16be_previous_path = calloc(1, UTF16_NAME_MAX);
1216	if (iso9660->utf16be_previous_path == NULL) {	1296	if (iso9660->utf16be_previous_path == NULL) {
1217	archive_set_error(&a->archive, ENOMEM,	1297	archive_set_error(&a->archive, ENOMEM,
1218	"No memory");	1298	"No memory");
Lines 1278-1290 archive_read_format_iso9660_read_header(struct archive_read *a, Link Here
1278	archive_entry_set_uid(entry, file->uid);	1358	archive_entry_set_uid(entry, file->uid);
1279	archive_entry_set_gid(entry, file->gid);	1359	archive_entry_set_gid(entry, file->gid);
1280	archive_entry_set_nlink(entry, file->nlinks);	1360	archive_entry_set_nlink(entry, file->nlinks);
1281	if (file->birthtime_is_set)	1361	if ((file->time_is_set & BIRTHTIME_IS_SET))
1282	archive_entry_set_birthtime(entry, file->birthtime, 0);	1362	archive_entry_set_birthtime(entry, file->birthtime, 0);
1283	else	1363	else
1284	archive_entry_unset_birthtime(entry);	1364	archive_entry_unset_birthtime(entry);
1285	archive_entry_set_mtime(entry, file->mtime, 0);	1365	if ((file->time_is_set & MTIME_IS_SET))
1286	archive_entry_set_ctime(entry, file->ctime, 0);	1366	archive_entry_set_mtime(entry, file->mtime, 0);
1287	archive_entry_set_atime(entry, file->atime, 0);	1367	else
		1368	archive_entry_unset_mtime(entry);
		1369	if ((file->time_is_set & CTIME_IS_SET))
		1370	archive_entry_set_ctime(entry, file->ctime, 0);
		1371	else
		1372	archive_entry_unset_ctime(entry);
		1373	if ((file->time_is_set & ATIME_IS_SET))
		1374	archive_entry_set_atime(entry, file->atime, 0);
		1375	else
		1376	archive_entry_unset_atime(entry);
1288	/* N.B.: Rock Ridge supports 64-bit device numbers. */	1377	/* N.B.: Rock Ridge supports 64-bit device numbers. */
1289	archive_entry_set_rdev(entry, (dev_t)file->rdev);	1378	archive_entry_set_rdev(entry, (dev_t)file->rdev);
1290	archive_entry_set_size(entry, iso9660->entry_bytes_remaining);	1379	archive_entry_set_size(entry, iso9660->entry_bytes_remaining);
Lines 1816-1822 parse_file_info(struct archive_read a, struct file_info parent, Link Here
1816	}	1905	}
1817		1906
1818	/* Create a new file entry and copy data from the ISO dir record. */	1907	/* Create a new file entry and copy data from the ISO dir record. */
1819	file = (struct file_info )calloc(1, sizeof(file));	1908	file = calloc(1, sizeof(*file));
1820	if (file == NULL) {	1909	if (file == NULL) {
1821	archive_set_error(&a->archive, ENOMEM,	1910	archive_set_error(&a->archive, ENOMEM,
1822	"No memory for file entry");	1911	"No memory for file entry");
Lines 1825-1832 parse_file_info(struct archive_read a, struct file_info parent, Link Here
1825	file->parent = parent;	1914	file->parent = parent;
1826	file->offset = offset;	1915	file->offset = offset;
1827	file->size = fsize;	1916	file->size = fsize;
1828	file->mtime = isodate7(isodirrec + DR_date_offset);	1917	if (isodate7_valid(isodirrec + DR_date_offset)) {
1829	file->ctime = file->atime = file->mtime;	1918	file->time_is_set \|= MTIME_IS_SET \| ATIME_IS_SET \| CTIME_IS_SET;
		1919	file->mtime = isodate7(isodirrec + DR_date_offset);
		1920	file->ctime = file->atime = file->mtime;
		1921	}
1830	file->rede_files.first = NULL;	1922	file->rede_files.first = NULL;
1831	file->rede_files.last = &(file->rede_files.first);	1923	file->rede_files.last = &(file->rede_files.first);
1832		1924
Lines 2500-2550 parse_rockridge_TF1(struct file_info file, const unsigned char data, Link Here
2500	/* Use 17-byte time format. */	2592	/* Use 17-byte time format. */
2501	if ((flag & 1) && data_length >= 17) {	2593	if ((flag & 1) && data_length >= 17) {
2502	/* Create time. */	2594	/* Create time. */
2503	file->birthtime_is_set = 1;	2595	if (isodate17_valid(data)) {
2504	file->birthtime = isodate17(data);	2596	file->time_is_set \|= BIRTHTIME_IS_SET;
		2597	file->birthtime = isodate17(data);
		2598	}
2505	data += 17;	2599	data += 17;
2506	data_length -= 17;	2600	data_length -= 17;
2507	}	2601	}
2508	if ((flag & 2) && data_length >= 17) {	2602	if ((flag & 2) && data_length >= 17) {
2509	/* Modify time. */	2603	/* Modify time. */
2510	file->mtime = isodate17(data);	2604	if (isodate17_valid(data)) {
		2605	file->time_is_set \|= MTIME_IS_SET;
		2606	file->mtime = isodate17(data);
		2607	}
2511	data += 17;	2608	data += 17;
2512	data_length -= 17;	2609	data_length -= 17;
2513	}	2610	}
2514	if ((flag & 4) && data_length >= 17) {	2611	if ((flag & 4) && data_length >= 17) {
2515	/* Access time. */	2612	/* Access time. */
2516	file->atime = isodate17(data);	2613	if (isodate17_valid(data)) {
		2614	file->time_is_set \|= ATIME_IS_SET;
		2615	file->atime = isodate17(data);
		2616	}
2517	data += 17;	2617	data += 17;
2518	data_length -= 17;	2618	data_length -= 17;
2519	}	2619	}
2520	if ((flag & 8) && data_length >= 17) {	2620	if ((flag & 8) && data_length >= 17) {
2521	/* Attribute change time. */	2621	/* Attribute change time. */
2522	file->ctime = isodate17(data);	2622	if (isodate17_valid(data)) {
		2623	file->time_is_set \|= CTIME_IS_SET;
		2624	file->ctime = isodate17(data);
		2625	}
2523	}	2626	}
2524	} else {	2627	} else {
2525	/* Use 7-byte time format. */	2628	/* Use 7-byte time format. */
2526	if ((flag & 1) && data_length >= 7) {	2629	if ((flag & 1) && data_length >= 7) {
2527	/* Create time. */	2630	/* Create time. */
2528	file->birthtime_is_set = 1;	2631	if (isodate7_valid(data)) {
2529	file->birthtime = isodate7(data);	2632	file->time_is_set \|= BIRTHTIME_IS_SET;
		2633	file->birthtime = isodate7(data);
		2634	}
2530	data += 7;	2635	data += 7;
2531	data_length -= 7;	2636	data_length -= 7;
2532	}	2637	}
2533	if ((flag & 2) && data_length >= 7) {	2638	if ((flag & 2) && data_length >= 7) {
2534	/* Modify time. */	2639	/* Modify time. */
2535	file->mtime = isodate7(data);	2640	if (isodate7_valid(data)) {
		2641	file->time_is_set \|= MTIME_IS_SET;
		2642	file->mtime = isodate7(data);
		2643	}
2536	data += 7;	2644	data += 7;
2537	data_length -= 7;	2645	data_length -= 7;
2538	}	2646	}
2539	if ((flag & 4) && data_length >= 7) {	2647	if ((flag & 4) && data_length >= 7) {
2540	/* Access time. */	2648	/* Access time. */
2541	file->atime = isodate7(data);	2649	if (isodate7_valid(data)) {
		2650	file->time_is_set \|= ATIME_IS_SET;
		2651	file->atime = isodate7(data);
		2652	}
2542	data += 7;	2653	data += 7;
2543	data_length -= 7;	2654	data_length -= 7;
2544	}	2655	}
2545	if ((flag & 8) && data_length >= 7) {	2656	if ((flag & 8) && data_length >= 7) {
2546	/* Attribute change time. */	2657	/* Attribute change time. */
2547	file->ctime = isodate7(data);	2658	if (isodate7_valid(data)) {
		2659	file->time_is_set \|= CTIME_IS_SET;
		2660	file->ctime = isodate7(data);
		2661	}
2548	}	2662	}
2549	}	2663	}
2550	}	2664	}
Lines 3033-3039 heap_add_entry(struct archive_read a, struct heap_queue heap, Link Here
3033	return (ARCHIVE_FATAL);	3147	return (ARCHIVE_FATAL);
3034	}	3148	}
3035	new_pending_files = (struct file_info **)	3149	new_pending_files = (struct file_info **)
3036	malloc(new_size * sizeof(new_pending_files[0]));	3150	calloc(new_size, sizeof(new_pending_files[0]));
3037	if (new_pending_files == NULL) {	3151	if (new_pending_files == NULL) {
3038	archive_set_error(&a->archive,	3152	archive_set_error(&a->archive,
3039	ENOMEM, "Out of memory");	3153	ENOMEM, "Out of memory");
Lines 3127-3132 toi(const void *p, int n) Link Here
3127	return (0);	3241	return (0);
3128	}	3242	}
3129		3243
		3244	/*
		3245	* ECMA119/ISO9660 stores multi-byte integers in one of
		3246	* three different formats:
		3247	* * Little-endian (specified in section 7.2.1 and 7.3.1)
		3248	* * Big-endian (specified in section 7.2.2 and 7.3.2)
		3249	* * Both (specified in section 7.2.3 and 7.3.3)
		3250	*
		3251	* For values that follow section 7.2.3 (16-bit) or 7.3.3 (32-bit), we
		3252	* can check that the little-endian and big-endian forms agree with
		3253	* each other. This helps us avoid trying to decode files that are
		3254	* not really ISO images.
		3255	*/
		3256	static int
		3257	isValid723Integer(const unsigned char *p) {
		3258	return (p[0] == p[3] && p[1] == p[2]);
		3259	}
		3260
		3261	static int
		3262	isValid733Integer(const unsigned char *p)
		3263	{
		3264	return (p[0] == p[7]
		3265	&& p[1] == p[6]
		3266	&& p[2] == p[5]
		3267	&& p[3] == p[4]);
		3268	}
		3269
		3270	static int
		3271	isodate7_valid(const unsigned char *v)
		3272	{
		3273	int year = v[0];
		3274	int month = v[1];
		3275	int day = v[2];
		3276	int hour = v[3];
		3277	int minute = v[4];
		3278	int second = v[5];
		3279	int gmt_off = (signed char)v[6];
		3280
		3281	/* ECMA-119 9.1.5 "If all seven values are zero, it shall mean
		3282	* that the date is unspecified" */
		3283	if (year == 0
		3284	&& month == 0
		3285	&& day == 0
		3286	&& hour == 0
		3287	&& minute == 0
		3288	&& second == 0
		3289	&& gmt_off == 0)
		3290	return 0;
		3291	/*
		3292	* Sanity-test each individual field
		3293	*/
		3294	/* Year can have any value */
		3295	/* Month must be 1-12 */
		3296	if (month < 1 \|\| month > 12)
		3297	return 0;
		3298	/* Day must be 1-31 */
		3299	if (day < 1 \|\| day > 31)
		3300	return 0;
		3301	/* Hour must be 0-23 */
		3302	if (hour > 23)
		3303	return 0;
		3304	/* Minute must be 0-59 */
		3305	if (minute > 59)
		3306	return 0;
		3307	/* second must be 0-59 according to ECMA-119 9.1.5 */
3308	/* BUT: we should probably allow for the time being in UTC, which
3309	allows up to 61 seconds in a minute in certain cases */
3310	if (second > 61)
3311	return 0;
3312	/* Offset from GMT must be -48 to +52 */
3313	if (gmt_off < -48 \|\| gmt_off > +52)
3314	return 0;
3315
3316	/* All tests pass, this is OK */
3317	return 1;
3318	}
3319
3130	static time_t	3320	static time_t
3131	isodate7(const unsigned char *v)	3321	isodate7(const unsigned char *v)
3132	{	3322	{
Lines 3153-3158 isodate7(const unsigned char *v) Link Here
3153	return (t);	3343	return (t);
3154	}	3344	}
3155		3345
		3346	static int
		3347	isodate17_valid(const unsigned char *v)
		3348	{
		3349	/* First 16 bytes are all ASCII digits */
		3350	for (int i = 0; i < 16; i++) {
		3351	if (v[i] < '0' \|\| v[i] > '9')
		3352	return 0;
		3353	}
		3354
		3355	int year = (v[0] - '0') * 1000 + (v[1] - '0') * 100
		3356	+ (v[2] - '0') * 10 + (v[3] - '0');
		3357	int month = (v[4] - '0') * 10 + (v[5] - '0');
		3358	int day = (v[6] - '0') * 10 + (v[7] - '0');
		3359	int hour = (v[8] - '0') * 10 + (v[9] - '0');
		3360	int minute = (v[10] - '0') * 10 + (v[11] - '0');
		3361	int second = (v[12] - '0') * 10 + (v[13] - '0');
		3362	int hundredths = (v[14] - '0') * 10 + (v[15] - '0');
		3363	int gmt_off = (signed char)v[16];
		3364
		3365	if (year == 0 && month == 0 && day == 0
		3366	&& hour == 0 && minute == 0 && second == 0
		3367	&& hundredths == 0 && gmt_off == 0)
		3368	return 0;
		3369	/*
		3370	* Sanity-test each individual field
		3371	*/
		3372
		3373	/* Year must be 1900-2300 */
		3374	/* (Not specified in ECMA-119, but these seem
		3375	like reasonable limits. */
		3376	if (year < 1900 \|\| year > 2300)
		3377	return 0;
		3378	/* Month must be 1-12 */
		3379	if (month < 1 \|\| month > 12)
		3380	return 0;
		3381	/* Day must be 1-31 */
		3382	if (day < 1 \|\| day > 31)
		3383	return 0;
		3384	/* Hour must be 0-23 */
		3385	if (hour > 23)
		3386	return 0;
		3387	/* Minute must be 0-59 */
		3388	if (minute > 59)
		3389	return 0;
		3390	/* second must be 0-59 according to ECMA-119 9.1.5 */
		3391	/* BUT: we should probably allow for the time being in UTC, which
		3392	allows up to 61 seconds in a minute in certain cases */
		3393	if (second > 61)
		3394	return 0;
		3395	/* Hundredths must be 0-99 */
		3396	if (hundredths > 99)
		3397	return 0;
		3398	/* Offset from GMT must be -48 to +52 */
		3399	if (gmt_off < -48 \|\| gmt_off > +52)
		3400	return 0;
		3401
		3402	/* All tests pass, this is OK */
		3403	return 1;
		3404
		3405	}
		3406
3156	static time_t	3407	static time_t
3157	isodate17(const unsigned char *v)	3408	isodate17(const unsigned char *v)
3158	{	3409	{
Lines 3164-3170 isodate17(const unsigned char *v) Link Here
3164	tm.tm_year = (v[0] - '0') * 1000 + (v[1] - '0') * 100	3415	tm.tm_year = (v[0] - '0') * 1000 + (v[1] - '0') * 100
3165	+ (v[2] - '0') * 10 + (v[3] - '0')	3416	+ (v[2] - '0') * 10 + (v[3] - '0')
3166	- 1900;	3417	- 1900;
3167	tm.tm_mon = (v[4] - '0') * 10 + (v[5] - '0');	3418	tm.tm_mon = (v[4] - '0') * 10 + (v[5] - '0') - 1;
3168	tm.tm_mday = (v[6] - '0') * 10 + (v[7] - '0');	3419	tm.tm_mday = (v[6] - '0') * 10 + (v[7] - '0');
3169	tm.tm_hour = (v[8] - '0') * 10 + (v[9] - '0');	3420	tm.tm_hour = (v[8] - '0') * 10 + (v[9] - '0');
3170	tm.tm_min = (v[10] - '0') * 10 + (v[11] - '0');	3421	tm.tm_min = (v[10] - '0') * 10 + (v[11] - '0');




static int	lha_read_file_header_2(struct archive_read *, struct lha *);
static int	lha_read_file_header_3(struct archive_read *, struct lha *);
static int	lha_read_file_extended_header(struct archive_read *,
		    struct lha *, uint16_t *, int, uint64_t, size_t *);
static size_t	lha_check_header_format(const void *);
static int	lha_skip_sfx(struct archive_read *);
static time_t	lha_dos_time(const unsigned char *);

	archive_check_magic(_a, ARCHIVE_READ_MAGIC,
	    ARCHIVE_STATE_NEW, "archive_read_support_format_lha");

	lha = calloc(1, sizeof(*lha));
	if (lha == NULL) {
		archive_set_error(&a->archive, ENOMEM,
		    "Can't allocate lha data");


	/* Read extended headers */
	err2 = lha_read_file_extended_header(a, lha, NULL, 2,
	    (uint64_t)(lha->compsize + 2), &extdsize);
	if (err2 < ARCHIVE_WARN)
		return (err2);
	if (err2 < err)

 */
static int
lha_read_file_extended_header(struct archive_read *a, struct lha *lha,
    uint16_t *crc, int sizefield_length, uint64_t limitsize, size_t *total_size)
{
	const void *h;
	const unsigned char *extdheader;

		}

		/* Sanity check to the extended header size. */
		if (((uint64_t)*total_size + extdsize) > limitsize ||
				    (uint64_t)limitsize ||
		    extdsize <= (size_t)sizefield_length)
			goto invalid;


Lines 273-279 archive_read_support_format_mtree(struct archive *_a) Link Here

(-)b/contrib/libarchive/libarchive/archive_read_support_format_mtree.c (-1 / +1 lines)
273	archive_check_magic(_a, ARCHIVE_READ_MAGIC,	273	archive_check_magic(_a, ARCHIVE_READ_MAGIC,
274	ARCHIVE_STATE_NEW, "archive_read_support_format_mtree");	274	ARCHIVE_STATE_NEW, "archive_read_support_format_mtree");
275		275
276	mtree = (struct mtree )calloc(1, sizeof(mtree));	276	mtree = calloc(1, sizeof(*mtree));
277	if (mtree == NULL) {	277	if (mtree == NULL) {
278	archive_set_error(&a->archive, ENOMEM,	278	archive_set_error(&a->archive, ENOMEM,
279	"Can't allocate mtree data");	279	"Can't allocate mtree data");

Lines 432-438 static int make_table_recurse(struct archive_read , struct huffman_code , int, Link Here

(-)b/contrib/libarchive/libarchive/archive_read_support_format_rar.c (-39 / +89 lines)
432	struct huffman_table_entry *, int, int);	432	struct huffman_table_entry *, int, int);
433	static int expand(struct archive_read , int64_t );	433	static int expand(struct archive_read , int64_t );
434	static int copy_from_lzss_window_to_unp(struct archive_read , const void *,	434	static int copy_from_lzss_window_to_unp(struct archive_read , const void *,
435	int64_t, int);	435	int64_t, size_t);
436	static const void rar_read_ahead(struct archive_read , size_t, ssize_t *);	436	static const void rar_read_ahead(struct archive_read , size_t, ssize_t *);
437	static int parse_filter(struct archive_read , const uint8_t , uint16_t,	437	static int parse_filter(struct archive_read , const uint8_t , uint16_t,
438	uint8_t);	438	uint8_t);
Lines 734-740 archive_read_support_format_rar(struct archive *_a) Link Here
734	archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,	734	archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
735	"archive_read_support_format_rar");	735	"archive_read_support_format_rar");
736		736
737	rar = (struct rar )calloc(1, sizeof(rar));	737	rar = calloc(1, sizeof(*rar));
738	if (rar == NULL)	738	if (rar == NULL)
739	{	739	{
740	archive_set_error(&a->archive, ENOMEM, "Can't allocate rar data");	740	archive_set_error(&a->archive, ENOMEM, "Can't allocate rar data");
Lines 1371-1378 read_header(struct archive_read a, struct archive_entry entry, Link Here
1371	char unp_size[8];	1371	char unp_size[8];
1372	int ttime;	1372	int ttime;
1373	struct archive_string_conv sconv, fn_sconv;	1373	struct archive_string_conv sconv, fn_sconv;
1374	unsigned long crc32_val;	1374	uint32_t crc32_computed, crc32_read;
1375	int ret = (ARCHIVE_OK), ret2;	1375	int ret = (ARCHIVE_OK), ret2;
		1376	char *newptr;
		1377	size_t newsize;
1376		1378
1377	rar = (struct rar *)(a->format->data);	1379	rar = (struct rar *)(a->format->data);
1378		1380
Lines 1400-1406 read_header(struct archive_read a, struct archive_entry entry, Link Here
1400	"Invalid header size");	1402	"Invalid header size");
1401	return (ARCHIVE_FATAL);	1403	return (ARCHIVE_FATAL);
1402	}	1404	}
1403	crc32_val = crc32(0, (const unsigned char *)p + 2, 7 - 2);	1405	crc32_computed = crc32(0, (const unsigned char *)p + 2, 7 - 2);
1404	__archive_read_consume(a, 7);	1406	__archive_read_consume(a, 7);
1405		1407
1406	if (!(rar->file_flags & FHD_SOLID))	1408	if (!(rar->file_flags & FHD_SOLID))
Lines 1434-1441 read_header(struct archive_read a, struct archive_entry entry, Link Here
1434	return (ARCHIVE_FATAL);	1436	return (ARCHIVE_FATAL);
1435		1437
1436	/* File Header CRC check. */	1438	/* File Header CRC check. */
1437	crc32_val = crc32(crc32_val, h, (unsigned)(header_size - 7));	1439	crc32_computed = crc32(crc32_computed, h, (unsigned)(header_size - 7));
1438	if ((crc32_val & 0xffff) != archive_le16dec(rar_header.crc)) {	1440	crc32_read = archive_le16dec(rar_header.crc);
		1441	if ((crc32_computed & 0xffff) != crc32_read) {
1439	#ifndef DONT_FAIL_ON_CRC_ERROR	1442	#ifndef DONT_FAIL_ON_CRC_ERROR
1440	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,	1443	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1441	"Header CRC error");	1444	"Header CRC error");
Lines 1469-1474 read_header(struct archive_read a, struct archive_entry entry, Link Here
1469		1472
1470	if (rar->file_flags & FHD_LARGE)	1473	if (rar->file_flags & FHD_LARGE)
1471	{	1474	{
		1475	if (p + 8 > endp) {
		1476	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
		1477	"Invalid header size");
		1478	return (ARCHIVE_FATAL);
		1479	}
1472	memcpy(packed_size, file_header.pack_size, 4);	1480	memcpy(packed_size, file_header.pack_size, 4);
1473	memcpy(packed_size + 4, p, 4); /* High pack size */	1481	memcpy(packed_size + 4, p, 4); /* High pack size */
1474	p += 4;	1482	p += 4;
Lines 1514-1521 read_header(struct archive_read a, struct archive_entry entry, Link Here
1514	return (ARCHIVE_FATAL);	1522	return (ARCHIVE_FATAL);
1515	}	1523	}
1516	if (rar->filename_allocated < filename_size * 2 + 2) {	1524	if (rar->filename_allocated < filename_size * 2 + 2) {
1517	char *newptr;	1525	newsize = filename_size * 2 + 2;
1518	size_t newsize = filename_size * 2 + 2;
1519	newptr = realloc(rar->filename, newsize);	1526	newptr = realloc(rar->filename, newsize);
1520	if (newptr == NULL) {	1527	if (newptr == NULL) {
1521	archive_set_error(&a->archive, ENOMEM,	1528	archive_set_error(&a->archive, ENOMEM,
Lines 1539-1545 read_header(struct archive_read a, struct archive_entry entry, Link Here
1539	fn_end = filename_size * 2;	1546	fn_end = filename_size * 2;
1540	filename_size = 0;	1547	filename_size = 0;
1541	offset = (unsigned)strlen(filename) + 1;	1548	offset = (unsigned)strlen(filename) + 1;
1542	highbyte = *(p + offset++);	1549	highbyte = offset >= end ? 0 : *(p + offset++);
1543	flagbits = 0;	1550	flagbits = 0;
1544	flagbyte = 0;	1551	flagbyte = 0;
1545	while (offset < end && filename_size < fn_end)	1552	while (offset < end && filename_size < fn_end)
Lines 1554-1567 read_header(struct archive_read a, struct archive_entry entry, Link Here
1554	switch((flagbyte >> flagbits) & 3)	1561	switch((flagbyte >> flagbits) & 3)
1555	{	1562	{
1556	case 0:	1563	case 0:
		1564	if (offset >= end)
		1565	continue;
1557	filename[filename_size++] = '\0';	1566	filename[filename_size++] = '\0';
1558	filename[filename_size++] = *(p + offset++);	1567	filename[filename_size++] = *(p + offset++);
1559	break;	1568	break;
1560	case 1:	1569	case 1:
		1570	if (offset >= end)
		1571	continue;
1561	filename[filename_size++] = highbyte;	1572	filename[filename_size++] = highbyte;
1562	filename[filename_size++] = *(p + offset++);	1573	filename[filename_size++] = *(p + offset++);
1563	break;	1574	break;
1564	case 2:	1575	case 2:
		1576	if (offset >= end - 1) {
		1577	offset = end;
		1578	continue;
		1579	}
1565	filename[filename_size++] = *(p + offset + 1);	1580	filename[filename_size++] = *(p + offset + 1);
1566	filename[filename_size++] = *(p + offset);	1581	filename[filename_size++] = *(p + offset);
1567	offset += 2;	1582	offset += 2;
Lines 1569-1577 read_header(struct archive_read a, struct archive_entry entry, Link Here
1569	case 3:	1584	case 3:
1570	{	1585	{
1571	char extra, high;	1586	char extra, high;
1572	uint8_t length = *(p + offset++);	1587	uint8_t length;
1573		1588
		1589	if (offset >= end)
		1590	continue;
		1591
		1592	length = *(p + offset++);
1574	if (length & 0x80) {	1593	if (length & 0x80) {
		1594	if (offset >= end)
		1595	continue;
1575	extra = *(p + offset++);	1596	extra = *(p + offset++);
1576	high = (char)highbyte;	1597	high = (char)highbyte;
1577	} else	1598	} else
Lines 1652-1664 read_header(struct archive_read a, struct archive_entry entry, Link Here
1652	rar->cursor++;	1673	rar->cursor++;
1653	if (rar->cursor >= rar->nodes)	1674	if (rar->cursor >= rar->nodes)
1654	{	1675	{
1655	rar->nodes++;	1676	struct data_block_offsets *newdbo;
1656	if ((rar->dbo =	1677
1657	realloc(rar->dbo, sizeof(rar->dbo) rar->nodes)) == NULL)	1678	newsize = sizeof(rar->dbo) (rar->nodes + 1);
		1679	if ((newdbo = realloc(rar->dbo, newsize)) == NULL)
1658	{	1680	{
1659	archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory.");	1681	archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory.");
1660	return (ARCHIVE_FATAL);	1682	return (ARCHIVE_FATAL);
1661	}	1683	}
		1684	rar->dbo = newdbo;
		1685	rar->nodes++;
1662	rar->dbo[rar->cursor].header_size = header_size;	1686	rar->dbo[rar->cursor].header_size = header_size;
1663	rar->dbo[rar->cursor].start_offset = -1;	1687	rar->dbo[rar->cursor].start_offset = -1;
1664	rar->dbo[rar->cursor].end_offset = -1;	1688	rar->dbo[rar->cursor].end_offset = -1;
Lines 1678-1686 read_header(struct archive_read a, struct archive_entry entry, Link Here
1678	return (ARCHIVE_FATAL);	1702	return (ARCHIVE_FATAL);
1679	}	1703	}
1680		1704
1681	rar->filename_save = (char*)realloc(rar->filename_save,	1705	newsize = filename_size + 1;
1682	filename_size + 1);	1706	if ((newptr = realloc(rar->filename_save, newsize)) == NULL)
1683	memcpy(rar->filename_save, rar->filename, filename_size + 1);	1707	{
		1708	archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory.");
		1709	return (ARCHIVE_FATAL);
		1710	}
		1711	rar->filename_save = newptr;
		1712	memcpy(rar->filename_save, rar->filename, newsize);
1684	rar->filename_save_size = filename_size;	1713	rar->filename_save_size = filename_size;
1685		1714
1686	/* Set info for seeking */	1715	/* Set info for seeking */
Lines 2060-2066 read_data_compressed(struct archive_read a, const void buff, size_t size, Link Here
2060	bs = rar->unp_buffer_size - rar->unp_offset;	2089	bs = rar->unp_buffer_size - rar->unp_offset;
2061	else	2090	else
2062	bs = (size_t)rar->bytes_uncopied;	2091	bs = (size_t)rar->bytes_uncopied;
2063	ret = copy_from_lzss_window_to_unp(a, buff, rar->offset, (int)bs);	2092	ret = copy_from_lzss_window_to_unp(a, buff, rar->offset, bs);
2064	if (ret != ARCHIVE_OK)	2093	if (ret != ARCHIVE_OK)
2065	return (ret);	2094	return (ret);
2066	rar->offset += bs;	2095	rar->offset += bs;
Lines 2213-2219 read_data_compressed(struct archive_read a, const void buff, size_t size, Link Here
2213	bs = rar->unp_buffer_size - rar->unp_offset;	2242	bs = rar->unp_buffer_size - rar->unp_offset;
2214	else	2243	else
2215	bs = (size_t)rar->bytes_uncopied;	2244	bs = (size_t)rar->bytes_uncopied;
2216	ret = copy_from_lzss_window_to_unp(a, buff, rar->offset, (int)bs);	2245	ret = copy_from_lzss_window_to_unp(a, buff, rar->offset, bs);
2217	if (ret != ARCHIVE_OK)	2246	if (ret != ARCHIVE_OK)
2218	return (ret);	2247	return (ret);
2219	rar->offset += bs;	2248	rar->offset += bs;
Lines 2579-2586 read_next_symbol(struct archive_read a, struct huffman_code code) Link Here
2579	rar_br_consume(br, code->tablesize);	2608	rar_br_consume(br, code->tablesize);
2580		2609
2581	node = value;	2610	node = value;
2582	while (!(code->tree[node].branches[0] ==	2611	while (code->tree[node].branches[0] != code->tree[node].branches[1])
2583	code->tree[node].branches[1]))
2584	{	2612	{
2585	if (!rar_br_read_ahead(a, br, 1)) {	2613	if (!rar_br_read_ahead(a, br, 1)) {
2586	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,	2614	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
Lines 2775-2783 make_table(struct archive_read a, struct huffman_code code) Link Here
2775	else	2803	else
2776	code->tablesize = code->maxlength;	2804	code->tablesize = code->maxlength;
2777		2805
2778	code->table =	2806	code->table = calloc(1U << code->tablesize, sizeof(*code->table));
2779	(struct huffman_table_entry )calloc(1, sizeof(code->table)
2780	* ((size_t)1 << code->tablesize));
2781		2807
2782	return make_table_recurse(a, code, 0, code->table, 0, code->tablesize);	2808	return make_table_recurse(a, code, 0, code->table, 0, code->tablesize);
2783	}	2809	}
Lines 2955-2961 expand(struct archive_read a, int64_t end) Link Here
2955		2981
2956	if ((lensymbol = read_next_symbol(a, &rar->lengthcode)) < 0)	2982	if ((lensymbol = read_next_symbol(a, &rar->lengthcode)) < 0)
2957	goto bad_data;	2983	goto bad_data;
2958	if (lensymbol > lengthb_min)	2984	if (lensymbol >= lengthb_min)
2959	goto bad_data;	2985	goto bad_data;
2960	len = lengthbases[lensymbol] + 2;	2986	len = lengthbases[lensymbol] + 2;
2961	if (lengthbits[lensymbol] > 0) {	2987	if (lengthbits[lensymbol] > 0) {
Lines 2987-2993 expand(struct archive_read a, int64_t end) Link Here
2987	}	3013	}
2988	else	3014	else
2989	{	3015	{
2990	if (symbol-271 > lengthb_min)	3016	if (symbol-271 >= lengthb_min)
2991	goto bad_data;	3017	goto bad_data;
2992	len = lengthbases[symbol-271]+3;	3018	len = lengthbases[symbol-271]+3;
2993	if(lengthbits[symbol-271] > 0) {	3019	if(lengthbits[symbol-271] > 0) {
Lines 2999-3005 expand(struct archive_read a, int64_t end) Link Here
2999		3025
3000	if ((offssymbol = read_next_symbol(a, &rar->offsetcode)) < 0)	3026	if ((offssymbol = read_next_symbol(a, &rar->offsetcode)) < 0)
3001	goto bad_data;	3027	goto bad_data;
3002	if (offssymbol > offsetb_min)	3028	if (offssymbol >= offsetb_min)
3003	goto bad_data;	3029	goto bad_data;
3004	offs = offsetbases[offssymbol]+1;	3030	offs = offsetbases[offssymbol]+1;
3005	if(offsetbits[offssymbol] > 0)	3031	if(offsetbits[offssymbol] > 0)
Lines 3094-3104 copy_from_lzss_window(struct archive_read a, void buffer, Link Here
3094		3120
3095	static int	3121	static int
3096	copy_from_lzss_window_to_unp(struct archive_read a, const void *buffer,	3122	copy_from_lzss_window_to_unp(struct archive_read a, const void *buffer,
3097	int64_t startpos, int length)	3123	int64_t startpos, size_t length)
3098	{	3124	{
3099	int windowoffs, firstpart;	3125	int windowoffs, firstpart;
3100	struct rar rar = (struct rar )(a->format->data);	3126	struct rar rar = (struct rar )(a->format->data);
3101		3127
		3128	if (length > rar->unp_buffer_size)
		3129	{
		3130	goto fatal;
		3131	}
		3132
3102	if (!rar->unp_buffer)	3133	if (!rar->unp_buffer)
3103	{	3134	{
3104	if ((rar->unp_buffer = malloc(rar->unp_buffer_size)) == NULL)	3135	if ((rar->unp_buffer = malloc(rar->unp_buffer_size)) == NULL)
Lines 3110-3126 copy_from_lzss_window_to_unp(struct archive_read a, const void *buffer, Link Here
3110	}	3141	}
3111		3142
3112	windowoffs = lzss_offset_for_position(&rar->lzss, startpos);	3143	windowoffs = lzss_offset_for_position(&rar->lzss, startpos);
3113	if(windowoffs + length <= lzss_size(&rar->lzss)) {	3144	if(windowoffs + length <= (size_t)lzss_size(&rar->lzss)) {
3114	memcpy(&rar->unp_buffer[rar->unp_offset], &rar->lzss.window[windowoffs],	3145	memcpy(&rar->unp_buffer[rar->unp_offset], &rar->lzss.window[windowoffs],
3115	length);	3146	length);
3116	} else if (length <= lzss_size(&rar->lzss)) {	3147	} else if (length <= (size_t)lzss_size(&rar->lzss)) {
3117	firstpart = lzss_size(&rar->lzss) - windowoffs;	3148	firstpart = lzss_size(&rar->lzss) - windowoffs;
3118	if (firstpart < 0) {	3149	if (firstpart < 0) {
3119	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,	3150	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
3120	"Bad RAR file data");	3151	"Bad RAR file data");
3121	return (ARCHIVE_FATAL);	3152	return (ARCHIVE_FATAL);
3122	}	3153	}
3123	if (firstpart < length) {	3154	if ((size_t)firstpart < length) {
3124	memcpy(&rar->unp_buffer[rar->unp_offset],	3155	memcpy(&rar->unp_buffer[rar->unp_offset],
3125	&rar->lzss.window[windowoffs], firstpart);	3156	&rar->lzss.window[windowoffs], firstpart);
3126	memcpy(&rar->unp_buffer[rar->unp_offset + firstpart],	3157	memcpy(&rar->unp_buffer[rar->unp_offset + firstpart],
Lines 3130-3145 copy_from_lzss_window_to_unp(struct archive_read a, const void *buffer, Link Here
3130	&rar->lzss.window[windowoffs], length);	3161	&rar->lzss.window[windowoffs], length);
3131	}	3162	}
3132	} else {	3163	} else {
3133	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,	3164	goto fatal;
3134	"Bad RAR file data");
3135	return (ARCHIVE_FATAL);
3136	}	3165	}
3137	rar->unp_offset += length;	3166	rar->unp_offset += (unsigned int) length;
3138	if (rar->unp_offset >= rar->unp_buffer_size)	3167	if (rar->unp_offset >= rar->unp_buffer_size)
3139	*buffer = rar->unp_buffer;	3168	*buffer = rar->unp_buffer;
3140	else	3169	else
3141	*buffer = NULL;	3170	*buffer = NULL;
3142	return (ARCHIVE_OK);	3171	return (ARCHIVE_OK);
		3172
		3173	fatal:
		3174	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
		3175	"Bad RAR file data");
		3176	return (ARCHIVE_FATAL);
3143	}	3177	}
3144		3178
3145	static const void *	3179	static const void *
Lines 3325-3331 create_filter(struct rar_program_code prog, const uint8_t globaldata, uint32_t Link Here
3325	filter->globaldatalen = globaldatalen > PROGRAM_SYSTEM_GLOBAL_SIZE ? globaldatalen : PROGRAM_SYSTEM_GLOBAL_SIZE;	3359	filter->globaldatalen = globaldatalen > PROGRAM_SYSTEM_GLOBAL_SIZE ? globaldatalen : PROGRAM_SYSTEM_GLOBAL_SIZE;
3326	filter->globaldata = calloc(1, filter->globaldatalen);	3360	filter->globaldata = calloc(1, filter->globaldatalen);
3327	if (!filter->globaldata)	3361	if (!filter->globaldata)
		3362	{
		3363	free(filter);
3328	return NULL;	3364	return NULL;
		3365	}
3329	if (globaldata)	3366	if (globaldata)
3330	memcpy(filter->globaldata, globaldata, globaldatalen);	3367	memcpy(filter->globaldata, globaldata, globaldatalen);
3331	if (registers)	3368	if (registers)
Lines 3352-3358 run_filters(struct archive_read *a) Link Here
3352	if (filters == NULL \|\| filter == NULL)	3389	if (filters == NULL \|\| filter == NULL)
3353	return (0);	3390	return (0);
3354		3391
3355	start = filters->filterstart;	3392	start = (size_t)filters->filterstart;
3356	end = start + filter->blocklength;	3393	end = start + filter->blocklength;
3357		3394
3358	filters->filterstart = INT64_MAX;	3395	filters->filterstart = INT64_MAX;
Lines 3389-3398 run_filters(struct archive_read *a) Link Here
3389	return 0;	3426	return 0;
3390	}	3427	}
3391		3428
		3429	if (filter->blocklength > VM_MEMORY_SIZE)
		3430	{
		3431	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, "Bad RAR file data");
		3432	return 0;
		3433	}
		3434
3392	ret = copy_from_lzss_window(a, filters->vm->memory, start, filter->blocklength);	3435	ret = copy_from_lzss_window(a, filters->vm->memory, start, filter->blocklength);
3393	if (ret != ARCHIVE_OK)	3436	if (ret != ARCHIVE_OK)
3394	return 0;	3437	return 0;
3395	if (!execute_filter(a, filter, filters->vm, rar->offset))	3438	if (!execute_filter(a, filter, filters->vm, (size_t)rar->offset))
3396	return 0;	3439	return 0;
3397		3440
3398	lastfilteraddress = filter->filteredblockaddress;	3441	lastfilteraddress = filter->filteredblockaddress;
Lines 3404-3410 run_filters(struct archive_read *a) Link Here
3404	while ((filter = filters->stack) != NULL && (int64_t)filter->blockstartpos == filters->filterstart && filter->blocklength == lastfilterlength)	3447	while ((filter = filters->stack) != NULL && (int64_t)filter->blockstartpos == filters->filterstart && filter->blocklength == lastfilterlength)
3405	{	3448	{
3406	memmove(&filters->vm->memory[0], &filters->vm->memory[lastfilteraddress], lastfilterlength);	3449	memmove(&filters->vm->memory[0], &filters->vm->memory[lastfilteraddress], lastfilterlength);
3407	if (!execute_filter(a, filter, filters->vm, rar->offset))	3450	if (!execute_filter(a, filter, filters->vm, (size_t)rar->offset))
3408	return 0;	3451	return 0;
3409		3452
3410	lastfilteraddress = filter->filteredblockaddress;	3453	lastfilteraddress = filter->filteredblockaddress;
Lines 3645-3651 execute_filter_e8(struct rar_filter filter, struct rar_virtual_machine vm, siz Link Here
3645	{	3688	{
3646	uint32_t currpos = (uint32_t)pos + i + 1;	3689	uint32_t currpos = (uint32_t)pos + i + 1;
3647	int32_t address = (int32_t)vm_read_32(vm, i + 1);	3690	int32_t address = (int32_t)vm_read_32(vm, i + 1);
3648	if (address < 0 && currpos >= (uint32_t)-address)	3691	if (address < 0 && currpos >= (~(uint32_t)address + 1))
3649	vm_write_32(vm, i + 1, address + filesize);	3692	vm_write_32(vm, i + 1, address + filesize);
3650	else if (address >= 0 && (uint32_t)address < filesize)	3693	else if (address >= 0 && (uint32_t)address < filesize)
3651	vm_write_32(vm, i + 1, address - currpos);	3694	vm_write_32(vm, i + 1, address - currpos);
Lines 3668-3674 execute_filter_rgb(struct rar_filter filter, struct rar_virtual_machine vm) Link Here
3668	uint8_t src, dst;	3711	uint8_t src, dst;
3669	uint32_t i, j;	3712	uint32_t i, j;
3670		3713
3671	if (blocklength > PROGRAM_WORK_SIZE / 2 \|\| stride > blocklength)	3714	if (blocklength > PROGRAM_WORK_SIZE / 2 \|\| stride > blocklength \|\| blocklength < 3 \|\| byteoffset > 2)
3672	return 0;	3715	return 0;
3673		3716
3674	src = &vm->memory[0];	3717	src = &vm->memory[0];
Lines 3678-3683 execute_filter_rgb(struct rar_filter filter, struct rar_virtual_machine vm) Link Here
3678	uint8_t *prev = dst + i - stride;	3721	uint8_t *prev = dst + i - stride;
3679	for (j = i; j < blocklength; j += 3)	3722	for (j = i; j < blocklength; j += 3)
3680	{	3723	{
		3724	/*
		3725	* The src block should not overlap with the dst block.
		3726	* If so it would be better to consider this archive is broken.
		3727	*/
		3728	if (src >= dst)
		3729	return 0;
		3730
3681	if (prev >= dst)	3731	if (prev >= dst)
3682	{	3732	{
3683	uint32_t delta1 = abs(prev[3] - prev[0]);	3733	uint32_t delta1 = abs(prev[3] - prev[0]);

Lines 210-216 struct comp_state { Link Here

(-)b/contrib/libarchive/libarchive/archive_read_support_format_rar5.c (-49 / +122 lines)
210	or just a part of it. */	210	or just a part of it. */
211	uint8_t block_parsing_finished : 1;	211	uint8_t block_parsing_finished : 1;
212		212
213	signed int notused : 4;	213	/* Flag used to indicate that a previous file using this buffer was
		214	encrypted, meaning no data in the buffer can be trusted */
		215	uint8_t data_encrypted : 1;
		216
		217	signed int notused : 3;
214		218
215	int flags; /* Uncompression flags. */	219	int flags; /* Uncompression flags. */
216	int method; /* Uncompression algorithm method. */	220	int method; /* Uncompression algorithm method. */
Lines 220-226 struct comp_state { Link Here
220	decompression. */	224	decompression. */
221	uint8_t* filtered_buf; /* Buffer used when applying filters. */	225	uint8_t* filtered_buf; /* Buffer used when applying filters. */
222	const uint8_t* block_buf; /* Buffer used when merging blocks. */	226	const uint8_t* block_buf; /* Buffer used when merging blocks. */
223	size_t window_mask; /* Convenience field; window_size - 1. */	227	ssize_t window_mask; /* Convenience field; window_size - 1. */
224	int64_t write_ptr; /* This amount of data has been unpacked	228	int64_t write_ptr; /* This amount of data has been unpacked
225	in the window buffer. */	229	in the window buffer. */
226	int64_t last_write_ptr; /* This amount of data has been stored in	230	int64_t last_write_ptr; /* This amount of data has been stored in
Lines 352-357 struct rar5 { Link Here
352	/* The header of currently processed RARv5 block. Used in main	356	/* The header of currently processed RARv5 block. Used in main
353	* decompression logic loop. */	357	* decompression logic loop. */
354	struct compressed_block_header last_block_hdr;	358	struct compressed_block_header last_block_hdr;
		359
		360	/*
		361	* Custom field to denote that this archive contains encrypted entries
		362	*/
		363	int has_encrypted_entries;
		364	int headers_are_encrypted;
355	};	365	};
356		366
357	/* Forward function declarations. */	367	/* Forward function declarations. */
Lines 361-366 static int verify_global_checksums(struct archive_read* a); Link Here
361	static int rar5_read_data_skip(struct archive_read *a);	371	static int rar5_read_data_skip(struct archive_read *a);
362	static int push_data_ready(struct archive_read* a, struct rar5* rar,	372	static int push_data_ready(struct archive_read* a, struct rar5* rar,
363	const uint8_t* buf, size_t size, int64_t offset);	373	const uint8_t* buf, size_t size, int64_t offset);
		374	static void clear_data_ready_stack(struct rar5* rar);
364		375
365	/* CDE_xxx = Circular Double Ended (Queue) return values. */	376	/* CDE_xxx = Circular Double Ended (Queue) return values. */
366	enum CDE_RETURN_VALUES {	377	enum CDE_RETURN_VALUES {
Lines 505-511 static inline struct rar5* get_context(struct archive_read* a) { Link Here
505	}	516	}
506		517
507	/* Convenience functions used by filter implementations. */	518	/* Convenience functions used by filter implementations. */
508	static void circular_memcpy(uint8_t* dst, uint8_t* window, const uint64_t mask,	519	static void circular_memcpy(uint8_t* dst, uint8_t* window, const ssize_t mask,
509	int64_t start, int64_t end)	520	int64_t start, int64_t end)
510	{	521	{
511	if((start & mask) > (end & mask)) {	522	if((start & mask) > (end & mask)) {
Lines 534-541 static void write_filter_data(struct rar5* rar, uint32_t offset, Link Here
534		545
535	/* Allocates a new filter descriptor and adds it to the filter array. */	546	/* Allocates a new filter descriptor and adds it to the filter array. */
536	static struct filter_info* add_new_filter(struct rar5* rar) {	547	static struct filter_info* add_new_filter(struct rar5* rar) {
537	struct filter_info* f =	548	struct filter_info* f = calloc(1, sizeof(*f));
538	(struct filter_info*) calloc(1, sizeof(struct filter_info));
539		549
540	if(!f) {	550	if(!f) {
541	return NULL;	551	return NULL;
Lines 652-657 static int run_filter(struct archive_read* a, struct filter_info* flt) { Link Here
652	int ret;	662	int ret;
653	struct rar5* rar = get_context(a);	663	struct rar5* rar = get_context(a);
654		664
		665	clear_data_ready_stack(rar);
655	free(rar->cstate.filtered_buf);	666	free(rar->cstate.filtered_buf);
656		667
657	rar->cstate.filtered_buf = malloc(flt->block_length);	668	rar->cstate.filtered_buf = malloc(flt->block_length);
Lines 709-715 static int run_filter(struct archive_read* a, struct filter_info* flt) { Link Here
709	static void push_data(struct archive_read* a, struct rar5* rar,	720	static void push_data(struct archive_read* a, struct rar5* rar,
710	const uint8_t* buf, int64_t idx_begin, int64_t idx_end)	721	const uint8_t* buf, int64_t idx_begin, int64_t idx_end)
711	{	722	{
712	const uint64_t wmask = rar->cstate.window_mask;	723	const ssize_t wmask = rar->cstate.window_mask;
713	const ssize_t solid_write_ptr = (rar->cstate.solid_offset +	724	const ssize_t solid_write_ptr = (rar->cstate.solid_offset +
714	rar->cstate.last_write_ptr) & wmask;	725	rar->cstate.last_write_ptr) & wmask;
715		726
Lines 1246-1252 static int process_main_locator_extra_block(struct archive_read* a, Link Here
1246	}	1257	}
1247		1258
1248	static int parse_file_extra_hash(struct archive_read* a, struct rar5* rar,	1259	static int parse_file_extra_hash(struct archive_read* a, struct rar5* rar,
1249	ssize_t* extra_data_size)	1260	int64_t* extra_data_size)
1250	{	1261	{
1251	size_t hash_type = 0;	1262	size_t hash_type = 0;
1252	size_t value_len;	1263	size_t value_len;
Lines 1296-1302 static uint64_t time_win_to_unix(uint64_t win_time) { Link Here
1296	}	1307	}
1297		1308
1298	static int parse_htime_item(struct archive_read* a, char unix_time,	1309	static int parse_htime_item(struct archive_read* a, char unix_time,
1299	uint64_t* where, ssize_t* extra_data_size)	1310	uint64_t* where, int64_t* extra_data_size)
1300	{	1311	{
1301	if(unix_time) {	1312	if(unix_time) {
1302	uint32_t time_val;	1313	uint32_t time_val;
Lines 1318-1324 static int parse_htime_item(struct archive_read* a, char unix_time, Link Here
1318	}	1329	}
1319		1330
1320	static int parse_file_extra_version(struct archive_read* a,	1331	static int parse_file_extra_version(struct archive_read* a,
1321	struct archive_entry* e, ssize_t* extra_data_size)	1332	struct archive_entry* e, int64_t* extra_data_size)
1322	{	1333	{
1323	size_t flags = 0;	1334	size_t flags = 0;
1324	size_t version = 0;	1335	size_t version = 0;
Lines 1372-1378 static int parse_file_extra_version(struct archive_read* a, Link Here
1372	}	1383	}
1373		1384
1374	static int parse_file_extra_htime(struct archive_read* a,	1385	static int parse_file_extra_htime(struct archive_read* a,
1375	struct archive_entry* e, struct rar5* rar, ssize_t* extra_data_size)	1386	struct archive_entry* e, struct rar5* rar, int64_t* extra_data_size)
1376	{	1387	{
1377	char unix_time = 0;	1388	char unix_time = 0;
1378	size_t flags = 0;	1389	size_t flags = 0;
Lines 1425-1431 static int parse_file_extra_htime(struct archive_read* a, Link Here
1425	}	1436	}
1426		1437
1427	static int parse_file_extra_redir(struct archive_read* a,	1438	static int parse_file_extra_redir(struct archive_read* a,
1428	struct archive_entry* e, struct rar5* rar, ssize_t* extra_data_size)	1439	struct archive_entry* e, struct rar5* rar, int64_t* extra_data_size)
1429	{	1440	{
1430	uint64_t value_size = 0;	1441	uint64_t value_size = 0;
1431	size_t target_size = 0;	1442	size_t target_size = 0;
Lines 1448-1456 static int parse_file_extra_redir(struct archive_read* a, Link Here
1448	return ARCHIVE_EOF;	1459	return ARCHIVE_EOF;
1449	*extra_data_size -= target_size + 1;	1460	*extra_data_size -= target_size + 1;
1450		1461
1451	if(!read_ahead(a, target_size, &p))
1452	return ARCHIVE_EOF;
1453
1454	if(target_size > (MAX_NAME_IN_CHARS - 1)) {	1462	if(target_size > (MAX_NAME_IN_CHARS - 1)) {
1455	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,	1463	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1456	"Link target is too long");	1464	"Link target is too long");
Lines 1463-1468 static int parse_file_extra_redir(struct archive_read* a, Link Here
1463	return ARCHIVE_FATAL;	1471	return ARCHIVE_FATAL;
1464	}	1472	}
1465		1473
		1474	if(!read_ahead(a, target_size, &p))
		1475	return ARCHIVE_EOF;
		1476
1466	memcpy(target_utf8_buf, p, target_size);	1477	memcpy(target_utf8_buf, p, target_size);
1467	target_utf8_buf[target_size] = 0;	1478	target_utf8_buf[target_size] = 0;
1468		1479
Lines 1496-1502 static int parse_file_extra_redir(struct archive_read* a, Link Here
1496	}	1507	}
1497		1508
1498	static int parse_file_extra_owner(struct archive_read* a,	1509	static int parse_file_extra_owner(struct archive_read* a,
1499	struct archive_entry* e, ssize_t* extra_data_size)	1510	struct archive_entry* e, int64_t* extra_data_size)
1500	{	1511	{
1501	uint64_t flags = 0;	1512	uint64_t flags = 0;
1502	uint64_t value_size = 0;	1513	uint64_t value_size = 0;
Lines 1576-1590 static int parse_file_extra_owner(struct archive_read* a, Link Here
1576	}	1587	}
1577		1588
1578	static int process_head_file_extra(struct archive_read* a,	1589	static int process_head_file_extra(struct archive_read* a,
1579	struct archive_entry* e, struct rar5* rar, ssize_t extra_data_size)	1590	struct archive_entry* e, struct rar5* rar, int64_t extra_data_size)
1580	{	1591	{
1581	size_t extra_field_size;	1592	uint64_t extra_field_size;
1582	size_t extra_field_id = 0;	1593	uint64_t extra_field_id = 0;
1583	int ret = ARCHIVE_FATAL;	1594	int ret = ARCHIVE_FATAL;
1584	size_t var_size;	1595	uint64_t var_size;
1585		1596
1586	while(extra_data_size > 0) {	1597	while(extra_data_size > 0) {
1587	if(!read_var_sized(a, &extra_field_size, &var_size))	1598	if(!read_var(a, &extra_field_size, &var_size))
1588	return ARCHIVE_EOF;	1599	return ARCHIVE_EOF;
1589		1600
1590	extra_data_size -= var_size;	1601	extra_data_size -= var_size;
Lines 1592-1600 static int process_head_file_extra(struct archive_read* a, Link Here
1592	return ARCHIVE_EOF;	1603	return ARCHIVE_EOF;
1593	}	1604	}
1594		1605
1595	if(!read_var_sized(a, &extra_field_id, &var_size))	1606	if(!read_var(a, &extra_field_id, &var_size))
1596	return ARCHIVE_EOF;	1607	return ARCHIVE_EOF;
1597		1608
		1609	extra_field_size -= var_size;
1598	extra_data_size -= var_size;	1610	extra_data_size -= var_size;
1599	if(ARCHIVE_OK != consume(a, var_size)) {	1611	if(ARCHIVE_OK != consume(a, var_size)) {
1600	return ARCHIVE_EOF;	1612	return ARCHIVE_EOF;
Lines 1622-1633 static int process_head_file_extra(struct archive_read* a, Link Here
1622	&extra_data_size);	1634	&extra_data_size);
1623	break;	1635	break;
1624	case EX_CRYPT:	1636	case EX_CRYPT:
		1637	/* Mark the entry as encrypted */
		1638	archive_entry_set_is_data_encrypted(e, 1);
		1639	rar->has_encrypted_entries = 1;
		1640	rar->cstate.data_encrypted = 1;
1625	/* fallthrough */	1641	/* fallthrough */
1626	case EX_SUBDATA:	1642	case EX_SUBDATA:
1627	/* fallthrough */	1643	/* fallthrough */
1628	default:	1644	default:
1629	/* Skip unsupported entry. */	1645	/* Skip unsupported entry. */
1630	return consume(a, extra_data_size);	1646	extra_data_size -= extra_field_size;
		1647	if (ARCHIVE_OK != consume(a, extra_field_size)) {
		1648	return ARCHIVE_EOF;
		1649	}
1631	}	1650	}
1632	}	1651	}
1633		1652
Lines 1642-1648 static int process_head_file_extra(struct archive_read* a, Link Here
1642	static int process_head_file(struct archive_read* a, struct rar5* rar,	1661	static int process_head_file(struct archive_read* a, struct rar5* rar,
1643	struct archive_entry* entry, size_t block_flags)	1662	struct archive_entry* entry, size_t block_flags)
1644	{	1663	{
1645	ssize_t extra_data_size = 0;	1664	int64_t extra_data_size = 0;
1646	size_t data_size = 0;	1665	size_t data_size = 0;
1647	size_t file_flags = 0;	1666	size_t file_flags = 0;
1648	size_t file_attr = 0;	1667	size_t file_attr = 0;
Lines 1682-1693 static int process_head_file(struct archive_read* a, struct rar5* rar, Link Here
1682	}	1701	}
1683		1702
1684	if(block_flags & HFL_EXTRA_DATA) {	1703	if(block_flags & HFL_EXTRA_DATA) {
1685	size_t edata_size = 0;	1704	uint64_t edata_size = 0;
1686	if(!read_var_sized(a, &edata_size, NULL))	1705	if(!read_var(a, &edata_size, NULL))
1687	return ARCHIVE_EOF;	1706	return ARCHIVE_EOF;
1688		1707
1689	/* Intentional type cast from unsigned to signed. */	1708	/* Intentional type cast from unsigned to signed. */
1690	extra_data_size = (ssize_t) edata_size;	1709	extra_data_size = (int64_t) edata_size;
1691	}	1710	}
1692		1711
1693	if(block_flags & HFL_DATA) {	1712	if(block_flags & HFL_DATA) {
Lines 1745-1753 static int process_head_file(struct archive_read* a, struct rar5* rar, Link Here
1745	rar->file.solid = (compression_info & SOLID) > 0;	1764	rar->file.solid = (compression_info & SOLID) > 0;
1746		1765
1747	/* Archives which declare solid files without initializing the window	1766	/* Archives which declare solid files without initializing the window
1748	* buffer first are invalid. */	1767	* buffer first are invalid, unless previous data was encrypted, in
		1768	* which case we may never have had the chance */
1749		1769
1750	if(rar->file.solid > 0 && rar->cstate.window_buf == NULL) {	1770	if(rar->file.solid > 0 && rar->cstate.data_encrypted == 0 &&
		1771	rar->cstate.window_buf == NULL) {
1751	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,	1772	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1752	"Declared solid file, but no window buffer "	1773	"Declared solid file, but no window buffer "
1753	"initialized yet.");	1774	"initialized yet.");
Lines 1776-1790 static int process_head_file(struct archive_read* a, struct rar5* rar, Link Here
1776	return ARCHIVE_FATAL;	1797	return ARCHIVE_FATAL;
1777	}	1798	}
1778	}	1799	}
		1800	else
		1801	rar->cstate.data_encrypted = 0; /* Reset for new buffer */
1779		1802
1780	if(rar->cstate.window_size < (ssize_t) window_size &&	1803	if(rar->cstate.window_size < (ssize_t) window_size &&
1781	rar->cstate.window_buf)	1804	rar->cstate.window_buf)
1782	{	1805	{
		1806	/* The `data_ready` stack contains pointers to the `window_buf` or
		1807	* `filtered_buf` buffers. Since we're about to reallocate the first
		1808	* buffer, some of those pointers could become invalid. Therefore, we
		1809	* need to dispose of all entries from the stack before attempting the
		1810	* realloc. */
		1811	clear_data_ready_stack(rar);
		1812
1783	/* If window_buf has been allocated before, reallocate it, so	1813	/* If window_buf has been allocated before, reallocate it, so
1784	* that its size will match new window_size. */	1814	* that its size will match new window_size. */
1785		1815
1786	uint8_t* new_window_buf =	1816	uint8_t* new_window_buf =
1787	realloc(rar->cstate.window_buf, window_size);	1817	realloc(rar->cstate.window_buf, (size_t) window_size);
1788		1818
1789	if(!new_window_buf) {	1819	if(!new_window_buf) {
1790	archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,	1820	archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
Lines 1837-1863 static int process_head_file(struct archive_read* a, struct rar5* rar, Link Here
1837		1867
1838	if (file_attr & (ATTR_READONLY \| ATTR_HIDDEN \| ATTR_SYSTEM)) {	1868	if (file_attr & (ATTR_READONLY \| ATTR_HIDDEN \| ATTR_SYSTEM)) {
1839	char fflags_text, ptr;	1869	char fflags_text, ptr;
1840	/* allocate for "rdonly,hidden,system," */	1870	/* allocate for ",rdonly,hidden,system" */
1841	fflags_text = malloc(22 * sizeof(char));	1871	fflags_text = malloc(22 * sizeof(*fflags_text));
1842	if (fflags_text != NULL) {	1872	if (fflags_text != NULL) {
1843	ptr = fflags_text;	1873	ptr = fflags_text;
1844	if (file_attr & ATTR_READONLY) {	1874	if (file_attr & ATTR_READONLY) {
1845	strcpy(ptr, "rdonly,");	1875	strcpy(ptr, ",rdonly");
1846	ptr = ptr + 7;	1876	ptr = ptr + 7;
1847	}	1877	}
1848	if (file_attr & ATTR_HIDDEN) {	1878	if (file_attr & ATTR_HIDDEN) {
1849	strcpy(ptr, "hidden,");	1879	strcpy(ptr, ",hidden");
1850	ptr = ptr + 7;	1880	ptr = ptr + 7;
1851	}	1881	}
1852	if (file_attr & ATTR_SYSTEM) {	1882	if (file_attr & ATTR_SYSTEM) {
1853	strcpy(ptr, "system,");	1883	strcpy(ptr, ",system");
1854	ptr = ptr + 7;	1884	ptr = ptr + 7;
1855	}	1885	}
1856	if (ptr > fflags_text) {	1886	if (ptr > fflags_text) {
1857	/* Delete trailing comma */
1858	*(ptr - 1) = '\0';
1859	archive_entry_copy_fflags_text(entry,	1887	archive_entry_copy_fflags_text(entry,
1860	fflags_text);	1888	fflags_text + 1);
1861	}	1889	}
1862	free(fflags_text);	1890	free(fflags_text);
1863	}	1891	}
Lines 1876-1884 static int process_head_file(struct archive_read* a, struct rar5* rar, Link Here
1876	if(!read_var_sized(a, &name_size, NULL))	1904	if(!read_var_sized(a, &name_size, NULL))
1877	return ARCHIVE_EOF;	1905	return ARCHIVE_EOF;
1878		1906
1879	if(!read_ahead(a, name_size, &p))
1880	return ARCHIVE_EOF;
1881
1882	if(name_size > (MAX_NAME_IN_CHARS - 1)) {	1907	if(name_size > (MAX_NAME_IN_CHARS - 1)) {
1883	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,	1908	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1884	"Filename is too long");	1909	"Filename is too long");
Lines 1893-1898 static int process_head_file(struct archive_read* a, struct rar5* rar, Link Here
1893	return ARCHIVE_FATAL;	1918	return ARCHIVE_FATAL;
1894	}	1919	}
1895		1920
		1921	if(!read_ahead(a, name_size, &p))
		1922	return ARCHIVE_EOF;
		1923
1896	memcpy(name_utf8_buf, p, name_size);	1924	memcpy(name_utf8_buf, p, name_size);
1897	name_utf8_buf[name_size] = 0;	1925	name_utf8_buf[name_size] = 0;
1898	if(ARCHIVE_OK != consume(a, name_size)) {	1926	if(ARCHIVE_OK != consume(a, name_size)) {
Lines 1980-1986 static int process_head_main(struct archive_read* a, struct rar5* rar, Link Here
1980	struct archive_entry* entry, size_t block_flags)	2008	struct archive_entry* entry, size_t block_flags)
1981	{	2009	{
1982	int ret;	2010	int ret;
1983	size_t extra_data_size = 0;	2011	uint64_t extra_data_size = 0;
1984	size_t extra_field_size = 0;	2012	size_t extra_field_size = 0;
1985	size_t extra_field_id = 0;	2013	size_t extra_field_id = 0;
1986	size_t archive_flags = 0;	2014	size_t archive_flags = 0;
Lines 2002-2008 static int process_head_main(struct archive_read* a, struct rar5* rar, Link Here
2002	(void) entry;	2030	(void) entry;
2003		2031
2004	if(block_flags & HFL_EXTRA_DATA) {	2032	if(block_flags & HFL_EXTRA_DATA) {
2005	if(!read_var_sized(a, &extra_data_size, NULL))	2033	if(!read_var(a, &extra_data_size, NULL))
2006	return ARCHIVE_EOF;	2034	return ARCHIVE_EOF;
2007	} else {	2035	} else {
2008	extra_data_size = 0;	2036	extra_data_size = 0;
Lines 2229-2238 static int process_base_block(struct archive_read* a, Link Here
2229	/* Verify the CRC32 of the header data. */	2257	/* Verify the CRC32 of the header data. */
2230	computed_crc = (uint32_t) crc32(0, p, (int) hdr_size);	2258	computed_crc = (uint32_t) crc32(0, p, (int) hdr_size);
2231	if(computed_crc != hdr_crc) {	2259	if(computed_crc != hdr_crc) {
		2260	#ifndef DONT_FAIL_ON_CRC_ERROR
2232	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,	2261	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2233	"Header CRC error");	2262	"Header CRC error");
2234		2263
2235	return ARCHIVE_FATAL;	2264	return ARCHIVE_FATAL;
		2265	#endif
2236	}	2266	}
2237		2267
2238	/* If the checksum is OK, we proceed with parsing. */	2268	/* If the checksum is OK, we proceed with parsing. */
Lines 2271-2276 static int process_base_block(struct archive_read* a, Link Here
2271	ret = process_head_file(a, rar, entry, header_flags);	2301	ret = process_head_file(a, rar, entry, header_flags);
2272	return ret;	2302	return ret;
2273	case HEAD_CRYPT:	2303	case HEAD_CRYPT:
		2304	archive_entry_set_is_metadata_encrypted(entry, 1);
		2305	archive_entry_set_is_data_encrypted(entry, 1);
		2306	rar->has_encrypted_entries = 1;
		2307	rar->headers_are_encrypted = 1;
2274	archive_set_error(&a->archive,	2308	archive_set_error(&a->archive,
2275	ARCHIVE_ERRNO_FILE_FORMAT,	2309	ARCHIVE_ERRNO_FILE_FORMAT,
2276	"Encryption is not supported");	2310	"Encryption is not supported");
Lines 2415-2420 static int rar5_read_header(struct archive_read *a, Link Here
2415	struct rar5* rar = get_context(a);	2449	struct rar5* rar = get_context(a);
2416	int ret;	2450	int ret;
2417		2451
		2452	/*
		2453	* It should be sufficient to call archive_read_next_header() for
		2454	* a reader to determine if an entry is encrypted or not.
		2455	*/
		2456	if (rar->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
		2457	rar->has_encrypted_entries = 0;
		2458	}
		2459
2418	if(rar->header_initialized == 0) {	2460	if(rar->header_initialized == 0) {
2419	init_header(a);	2461	init_header(a);
2420	if ((ret = try_skip_sfx(a)) < ARCHIVE_WARN)	2462	if ((ret = try_skip_sfx(a)) < ARCHIVE_WARN)
Lines 2453-2458 static void init_unpack(struct rar5* rar) { Link Here
2453	rar->cstate.filtered_buf = NULL;	2495	rar->cstate.filtered_buf = NULL;
2454	}	2496	}
2455		2497
		2498	clear_data_ready_stack(rar);
		2499
2456	rar->cstate.write_ptr = 0;	2500	rar->cstate.write_ptr = 0;
2457	rar->cstate.last_write_ptr = 0;	2501	rar->cstate.last_write_ptr = 0;
2458		2502
Lines 2983-2989 static int decode_code_length(struct archive_read* a, struct rar5* rar, Link Here
2983		3027
2984	static int copy_string(struct archive_read* a, int len, int dist) {	3028	static int copy_string(struct archive_read* a, int len, int dist) {
2985	struct rar5* rar = get_context(a);	3029	struct rar5* rar = get_context(a);
2986	const uint64_t cmask = rar->cstate.window_mask;	3030	const ssize_t cmask = rar->cstate.window_mask;
2987	const uint64_t write_ptr = rar->cstate.write_ptr +	3031	const uint64_t write_ptr = rar->cstate.write_ptr +
2988	rar->cstate.solid_offset;	3032	rar->cstate.solid_offset;
2989	int i;	3033	int i;
Lines 3627-3632 static int use_data(struct rar5* rar, const void** buf, size_t* size, Link Here
3627	return ARCHIVE_RETRY;	3671	return ARCHIVE_RETRY;
3628	}	3672	}
3629		3673
		3674	static void clear_data_ready_stack(struct rar5* rar) {
		3675	memset(&rar->cstate.dready, 0, sizeof(rar->cstate.dready));
		3676	}
		3677
3630	/* Pushes the `buf`, `size` and `offset` arguments to the rar->cstate.dready	3678	/* Pushes the `buf`, `size` and `offset` arguments to the rar->cstate.dready
3631	* FIFO stack. Those values will be popped from this stack by the `use_data`	3679	* FIFO stack. Those values will be popped from this stack by the `use_data`
3632	* function. */	3680	* function. */
Lines 4069-4074 static int rar5_read_data(struct archive_read a, const void *buff, Link Here
4069	if (size)	4117	if (size)
4070	*size = 0;	4118	*size = 0;
4071		4119
		4120	if (rar->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
		4121	rar->has_encrypted_entries = 0;
		4122	}
		4123
		4124	if (rar->headers_are_encrypted \|\| rar->cstate.data_encrypted) {
		4125	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
		4126	"Reading encrypted data is not currently supported");
		4127	return ARCHIVE_FATAL;
		4128	}
		4129
4072	if(rar->file.dir > 0) {	4130	if(rar->file.dir > 0) {
4073	/* Don't process any data if this file entry was declared	4131	/* Don't process any data if this file entry was declared
4074	* as a directory. This is needed, because entries marked as	4132	* as a directory. This is needed, because entries marked as
Lines 4120-4130 static int rar5_read_data(struct archive_read a, const void *buff, Link Here
4120	static int rar5_read_data_skip(struct archive_read *a) {	4178	static int rar5_read_data_skip(struct archive_read *a) {
4121	struct rar5* rar = get_context(a);	4179	struct rar5* rar = get_context(a);
4122		4180
4123	if(rar->main.solid) {	4181	if(rar->main.solid && (rar->cstate.data_encrypted == 0)) {
4124	/* In solid archives, instead of skipping the data, we need to	4182	/* In solid archives, instead of skipping the data, we need to
4125	* extract it, and dispose the result. The side effect of this	4183	* extract it, and dispose the result. The side effect of this
4126	* operation will be setting up the initial window buffer state	4184	* operation will be setting up the initial window buffer state
4127	* needed to be able to extract the selected file. */	4185	* needed to be able to extract the selected file. Note that
		4186	* this is only possible when data withing this solid block is
		4187	* not encrypted, in which case we'll skip and fail if the user
		4188	* tries to read data. */
4128		4189
4129	int ret;	4190	int ret;
4130		4191
Lines 4185-4190 static int rar5_cleanup(struct archive_read *a) { Link Here
4185		4246
4186	free(rar->cstate.window_buf);	4247	free(rar->cstate.window_buf);
4187	free(rar->cstate.filtered_buf);	4248	free(rar->cstate.filtered_buf);
		4249	clear_data_ready_stack(rar);
4188		4250
4189	free(rar->vol.push_buf);	4251	free(rar->vol.push_buf);
4190		4252
Lines 4199-4212 static int rar5_cleanup(struct archive_read *a) { Link Here
4199		4261
4200	static int rar5_capabilities(struct archive_read * a) {	4262	static int rar5_capabilities(struct archive_read * a) {
4201	(void) a;	4263	(void) a;
4202	return 0;	4264	return (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA
		4265	\| ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA);
4203	}	4266	}
4204		4267
4205	static int rar5_has_encrypted_entries(struct archive_read *_a) {	4268	static int rar5_has_encrypted_entries(struct archive_read *_a) {
4206	(void) _a;	4269	if (_a && _a->format) {
		4270	struct rar5 rar = (struct rar5 )_a->format->data;
		4271	if (rar) {
		4272	return rar->has_encrypted_entries;
		4273	}
		4274	}
4207		4275
4208	/* Unsupported for now. */	4276	return ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;
4209	return ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED;
4210	}	4277	}
4211		4278
4212	static int rar5_init(struct rar5* rar) {	4279	static int rar5_init(struct rar5* rar) {
Lines 4215-4220 static int rar5_init(struct rar5* rar) { Link Here
4215	if(CDE_OK != cdeque_init(&rar->cstate.filters, 8192))	4282	if(CDE_OK != cdeque_init(&rar->cstate.filters, 8192))
4216	return ARCHIVE_FATAL;	4283	return ARCHIVE_FATAL;
4217		4284
		4285	/*
		4286	* Until enough data has been read, we cannot tell about
		4287	* any encrypted entries yet.
		4288	*/
		4289	rar->has_encrypted_entries = ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;
		4290
4218	return ARCHIVE_OK;	4291	return ARCHIVE_OK;
4219	}	4292	}
4220		4293

Lines 61-67 archive_read_support_format_raw(struct archive *_a) Link Here

(-)b/contrib/libarchive/libarchive/archive_read_support_format_raw.c (-1 / +1 lines)
61	archive_check_magic(_a, ARCHIVE_READ_MAGIC,	61	archive_check_magic(_a, ARCHIVE_READ_MAGIC,
62	ARCHIVE_STATE_NEW, "archive_read_support_format_raw");	62	ARCHIVE_STATE_NEW, "archive_read_support_format_raw");
63		63
64	info = (struct raw_info )calloc(1, sizeof(info));	64	info = calloc(1, sizeof(*info));
65	if (info == NULL) {	65	if (info == NULL) {
66	archive_set_error(&a->archive, ENOMEM,	66	archive_set_error(&a->archive, ENOMEM,
67	"Can't allocate raw_info data");	67	"Can't allocate raw_info data");




/*-
 * Copyright (c) 2003-2023 Tim Kientzle
 * Copyright (c) 2011-2012 Michihiro NAKAJIMA
 * Copyright (c) 2016 Martin Matuska
 * All rights reserved.

};

struct tar {
	struct archive_string	 acl_text;
	struct archive_string	 entry_pathname;
	/* For "GNU.sparse.name" and other similar path extensions. */
	struct archive_string	 entry_pathname_override;
	struct archive_string	 entry_linkpath;
	struct archive_string	 entry_uname;
	struct archive_string	 entry_gname;
	struct archive_string	 entry_linkpath;
	struct archive_string	 longname;
	struct archive_string	 pax_header;
	struct archive_string	 pax_global;
	struct archive_string	 line;
	int			 pax_hdrcharset_utf8;
	int			 header_recursion_depth;
	int64_t			 entry_bytes_remaining;
	int64_t			 entry_offset;
	int64_t			 entry_padding;
	int64_t 		 entry_bytes_unconsumed;
	int64_t			 realsize;
	int			 sparse_allowed;
	struct sparse_block	*sparse_list;
	struct sparse_block	*sparse_last;
	int64_t			 sparse_offset;
	int64_t			 sparse_numbytes;
	int			 sparse_gnu_major;
	int			 sparse_gnu_minor;
	char			 sparse_gnu_attributes_seen;
	char			 filetype;

	struct archive_string	 localname;
	struct archive_string_conv *opt_sconv;

static int	gnu_sparse_old_parse(struct archive_read *, struct tar *,
		    const struct gnu_sparse *sparse, int length);
static int	gnu_sparse_01_parse(struct archive_read *, struct tar *,
		    const char *, size_t);
static ssize_t	gnu_sparse_10_read(struct archive_read *, struct tar *,
		    size_t *);
static int	header_Solaris_ACL(struct archive_read *,  struct tar *,
		    struct archive_entry *, const void *, size_t *);
static int	header_common(struct archive_read *,  struct tar *,
		    struct archive_entry *, const void *);
static int	header_old_tar(struct archive_read *, struct tar *,
		    struct archive_entry *, const void *);
static int	header_pax_extension(struct archive_read *, struct tar *,
		    struct archive_entry *, const void *, size_t *);
static int	header_pax_global(struct archive_read *, struct tar *,
		    struct archive_entry *, const void *h, size_t *);
static int	header_gnu_longlink(struct archive_read *, struct tar *,
		    struct archive_entry *, const void *h, size_t *);
static int	header_longname(struct archive_read *, struct tar *,
		    struct archive_entry *, const void *h, size_t *);
static int	header_gnu_longname(struct archive_read *, struct tar *,
		    struct archive_entry *, const void *h, size_t *);
static int	is_mac_metadata_entry(struct archive_entry *entry);
static int	read_mac_metadata_blob(struct archive_read *,
		    struct archive_entry *, size_t *);
static int	header_volume(struct archive_read *, struct tar *,
		    struct archive_entry *, const void *h, size_t *);
static int	header_ustar(struct archive_read *, struct tar *,

		    struct archive_entry *);
static int	checksum(struct archive_read *, const void *);
static int 	pax_attribute(struct archive_read *, struct tar *,
		    struct archive_entry *, const char *key, size_t key_length,
		    size_t value_length, size_t *unconsumed);
static int	pax_attribute_LIBARCHIVE_xattr(struct archive_entry *,
		    const char *, size_t, const char *, size_t);
static int	pax_attribute_SCHILY_acl(struct archive_read *, struct tar *,
		    struct archive_entry *, size_t, int);
static int	pax_attribute_SUN_holesdata(struct archive_read *, struct tar *,
		    struct archive_entry *, const char *, size_t);
static void	pax_time(const char *, size_t, int64_t *sec, long *nanos);
static ssize_t	readline(struct archive_read *, struct tar *, const char **,
		    ssize_t limit, size_t *);
static int	read_body_to_string(struct archive_read *, struct tar *,
		    struct archive_string *, const void *h, size_t *);
static int	read_bytes_to_string(struct archive_read *,
		    struct archive_string *, size_t, size_t *);
static int64_t	tar_atol(const char *, size_t);
static int64_t	tar_atol10(const char *, size_t);
static int64_t	tar_atol256(const char *, size_t);

static int	tar_read_header(struct archive_read *, struct tar *,
		    struct archive_entry *, size_t *);
static int	tohex(int c);
static char	*url_decode(const char *, size_t);
static void	tar_flush_unconsumed(struct archive_read *, size_t *);

/* Sanity limits:  These numbers should be low enough to
 * prevent a maliciously-crafted archive from forcing us to
 * allocate extreme amounts of memory.  But of course, they
 * need to be high enough for any correct value.  These
 * will likely need some adjustment as we get more experience. */
static const size_t guname_limit = 65536; /* Longest uname or gname: 64kiB */
static const size_t pathname_limit = 1048576; /* Longest path name: 1MiB */
static const size_t sparse_map_limit = 8 * 1048576; /* Longest sparse map: 8MiB */
static const size_t xattr_limit = 16 * 1048576; /* Longest xattr: 16MiB */
static const size_t fflags_limit = 512; /* Longest fflags */
static const size_t acl_limit = 131072; /* Longest textual ACL: 128kiB */
static const int64_t entry_limit = 0xfffffffffffffffLL; /* 2^60 bytes = 1 ExbiByte */

int
archive_read_support_format_gnutar(struct archive *a)

	archive_check_magic(_a, ARCHIVE_READ_MAGIC,
	    ARCHIVE_STATE_NEW, "archive_read_support_format_tar");

	tar = calloc(1, sizeof(*tar));
	if (tar == NULL) {
		archive_set_error(&a->archive, ENOMEM,
		    "Can't allocate tar data");


	tar = (struct tar *)(a->format->data);
	gnu_clear_sparse_list(tar);
	archive_string_free(&tar->acl_text);
	archive_string_free(&tar->entry_pathname);
	archive_string_free(&tar->entry_pathname_override);
	archive_string_free(&tar->entry_linkpath);
	archive_string_free(&tar->entry_uname);
	archive_string_free(&tar->entry_gname);
	archive_string_free(&tar->entry_linkpath);
	archive_string_free(&tar->line);
	archive_string_free(&tar->pax_global);
	archive_string_free(&tar->pax_header);
	archive_string_free(&tar->longname);
	archive_string_free(&tar->longlink);
	archive_string_free(&tar->localname);
	free(tar);
	(a->format->data) = NULL;

	 * probably not worthwhile just to support the relatively
	 * obscure tar->cpio conversion case.
	 */
	/* TODO: Move this into `struct tar` to avoid conflicts
	 * when reading multiple archives */
	static int default_inode;
	static int default_dev;
	struct tar *tar;

		}

		*buff = __archive_read_ahead(a, 1, &bytes_read);
		if (bytes_read < 0)
			return (ARCHIVE_FATAL);
		if (*buff == NULL) {
			archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
			    "Truncated tar archive"
			    " detected while reading data");
			return (ARCHIVE_FATAL);
		}
		if (bytes_read > tar->entry_bytes_remaining)

}

/*
 * This function reads and interprets all of the headers associated
 * with a single entry.
 */
static int

    struct archive_entry *entry, size_t *unconsumed)
{
	ssize_t bytes;
	int err = ARCHIVE_OK, err2;
	int eof_fatal = 0; /* EOF is okay at some points... */
	const char *h;
	const struct archive_entry_header_ustar *header;
	const struct archive_entry_header_gnutar *gnuheader;

	/* Bitmask of what header types we've seen. */
	int32_t seen_headers = 0;
	static const int32_t seen_A_header = 1;
	static const int32_t seen_g_header = 2;
	static const int32_t seen_K_header = 4;
	static const int32_t seen_L_header = 8;
	static const int32_t seen_V_header = 16;
	static const int32_t seen_x_header = 32; /* Also X */
	static const int32_t seen_mac_metadata = 512;

	tar->pax_hdrcharset_utf8 = 1;
	tar->sparse_gnu_attributes_seen = 0;
	archive_string_empty(&(tar->entry_gname));
	archive_string_empty(&(tar->entry_pathname));
	archive_string_empty(&(tar->entry_pathname_override));
	archive_string_empty(&(tar->entry_uname));
	archive_string_empty(&tar->entry_linkpath);

	/* Ensure format is set. */
	if (a->archive.archive_format_name == NULL) {
		a->archive.archive_format = ARCHIVE_FORMAT_TAR;
		a->archive.archive_format_name = "tar";
	}
			/* Some writers do omit the block of nulls. <sigh> */
			return (ARCHIVE_EOF);
		}
		if (bytes < 512) {  /* Short block at EOF; this is bad. */
			archive_set_error(&a->archive,
			    ARCHIVE_ERRNO_FILE_FORMAT,
			    "Truncated tar archive");
			return (ARCHIVE_FATAL);
		}
		*unconsumed = 512;

	/*
	 * TODO: Write global/default pax options into
	 * 'entry' struct here before overwriting with
	 * file-specific options.
	 */

	/* Loop over all the headers needed for the next entry */
	for (;;) {
			a->archive.archive_format = ARCHIVE_FORMAT_TAR;
			a->archive.archive_format_name = "tar";
		}

		/* Find the next valid header record. */
		while (1) {
			tar_flush_unconsumed(a, unconsumed);
			h = __archive_read_ahead(a, 512, NULL);
			if (h != NULL && h[0] == 0 && archive_block_is_null(h))
				__archive_read_consume(a, 512);
			archive_clear_error(&a->archive);
			return (ARCHIVE_EOF);
		}

			/* Read 512-byte header record */
			h = __archive_read_ahead(a, 512, &bytes);
			if (bytes == 0) { /* EOF at a block boundary. */
				if (eof_fatal) {
					/* We've read a special header already;
					 * if there's no regular header, then this is
					 * a premature EOF. */
					archive_set_error(&a->archive, EINVAL,
							  "Damaged tar archive");
					return (ARCHIVE_FATAL);
				} else {
					return (ARCHIVE_EOF);
				}
			}
			if (h == NULL) {  /* Short block at EOF; this is bad. */
				archive_set_error(&a->archive,
				    ARCHIVE_ERRNO_FILE_FORMAT,
				    "Truncated tar archive"
				    " detected while reading next heaader");
				return (ARCHIVE_FATAL);
			}
			*unconsumed += 512;

			if (h[0] == 0 && archive_block_is_null(h)) {
				/* We found a NULL block which indicates end-of-archive */
	 * then the client is likely to just retry.  This is a very
	 * crude way to search for the next valid header!
	 *
	 * TODO: Improve this by implementing a real header scan.
	 */
	if (!checksum(a, h)) {
		tar_flush_unconsumed(a, unconsumed);
		archive_set_error(&a->archive, EINVAL, "Damaged tar archive");
		return (ARCHIVE_RETRY); /* Retryable: Invalid header */
	}

				if (tar->read_concatenated_archives) {
					/* We're ignoring NULL blocks, so keep going. */
					continue;
				}
	}

				/* Try to consume a second all-null record, as well. */
				/* If we can't, that's okay. */
				tar_flush_unconsumed(a, unconsumed);
				h = __archive_read_ahead(a, 512, NULL);
				if (h != NULL && h[0] == 0 && archive_block_is_null(h))
						__archive_read_consume(a, 512);

				archive_clear_error(&a->archive);
				return (ARCHIVE_EOF);
		a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
		a->archive.archive_format_name = "Solaris tar";
		err = header_Solaris_ACL(a, tar, entry, h, unconsumed);
		break;
	case 'g': /* POSIX-standard 'g' header. */
		a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
		a->archive.archive_format_name = "POSIX pax interchange format";
		err = header_pax_global(a, tar, entry, h, unconsumed);
		if (err == ARCHIVE_EOF)
			return (err);
		break;
	case 'K': /* Long link name (GNU tar, others) */
		err = header_longlink(a, tar, entry, h, unconsumed);
		break;
	case 'L': /* Long filename (GNU tar, others) */
		err = header_longname(a, tar, entry, h, unconsumed);
		break;
	case 'V': /* GNU volume header */
		err = header_volume(a, tar, entry, h, unconsumed);
		if (err == ARCHIVE_EOF)
			eof_vol_header = 1;
		break;
	case 'X': /* Used by SUN tar; same as 'x'. */
		a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
		a->archive.archive_format_name =
		    "POSIX pax interchange format (Sun variant)";
		err = header_pax_extensions(a, tar, entry, h, unconsumed);
		break;
	case 'x': /* POSIX-standard 'x' header. */
		a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
		a->archive.archive_format_name = "POSIX pax interchange format";
		err = header_pax_extensions(a, tar, entry, h, unconsumed);
		break;
	default:
		gnuheader = (const struct archive_entry_header_gnutar *)h;
		if (memcmp(gnuheader->magic, "ustar  \0", 8) == 0) {
			a->archive.archive_format = ARCHIVE_FORMAT_TAR_GNUTAR;
			a->archive.archive_format_name = "GNU tar format";
			err = header_gnutar(a, tar, entry, h, unconsumed);
		} else if (memcmp(header->magic, "ustar", 5) == 0) {
			if (a->archive.archive_format != ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE) {
				a->archive.archive_format = ARCHIVE_FORMAT_TAR_USTAR;
				a->archive.archive_format_name = "POSIX ustar format";
			}
			err = header_ustar(a, tar, entry, h);
		} else {
			a->archive.archive_format = ARCHIVE_FORMAT_TAR;
			a->archive.archive_format_name = "tar (non-POSIX)";
			err = header_old_tar(a, tar, entry, h);
		}
	}
	if (err == ARCHIVE_FATAL)
		return (err);

	tar_flush_unconsumed(a, unconsumed);

			/* This is NOT a null block, so it must be a valid header. */
			if (!checksum(a, h)) {
				tar_flush_unconsumed(a, unconsumed);
				archive_set_error(&a->archive, EINVAL, "Damaged tar archive");
				/* If we've read some critical information (pax headers, etc)
				 * and _then_ see a bad header, we can't really recover. */
				if (eof_fatal) {
					return (ARCHIVE_FATAL);
				} else {
					return (ARCHIVE_RETRY);
				}
			}
			break;
		}

		/* Determine the format variant. */
		header = (const struct archive_entry_header_ustar *)h;
		switch(header->typeflag[0]) {
		case 'A': /* Solaris tar ACL */
			if (seen_headers & seen_A_header) {
				return (ARCHIVE_FATAL);
			}
			seen_headers |= seen_A_header;
			a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
			a->archive.archive_format_name = "Solaris tar";
			err2 = header_Solaris_ACL(a, tar, entry, h, unconsumed);
			break;
		case 'g': /* POSIX-standard 'g' header. */
			if (seen_headers & seen_g_header) {
				return (ARCHIVE_FATAL);
			}
			seen_headers |= seen_g_header;
			a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
			a->archive.archive_format_name = "POSIX pax interchange format";
			err2 = header_pax_global(a, tar, entry, h, unconsumed);
			break;
		case 'K': /* Long link name (GNU tar, others) */
			if (seen_headers & seen_K_header) {
				return (ARCHIVE_FATAL);
			}
			seen_headers |= seen_K_header;
			err2 = header_gnu_longlink(a, tar, entry, h, unconsumed);
			break;
		case 'L': /* Long filename (GNU tar, others) */
			if (seen_headers & seen_L_header) {
				return (ARCHIVE_FATAL);
			}
			seen_headers |= seen_L_header;
			err2 = header_gnu_longname(a, tar, entry, h, unconsumed);
			break;
		case 'V': /* GNU volume header */
			if (seen_headers & seen_V_header) {
				return (ARCHIVE_FATAL);
			}
			seen_headers |= seen_V_header;
			err2 = header_volume(a, tar, entry, h, unconsumed);
			break;
		case 'X': /* Used by SUN tar; same as 'x'. */
			if (seen_headers & seen_x_header) {
				return (ARCHIVE_FATAL);
			}
			seen_headers |= seen_x_header;
			a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
			a->archive.archive_format_name =
				"POSIX pax interchange format (Sun variant)";
			err2 = header_pax_extension(a, tar, entry, h, unconsumed);
			break;
		case 'x': /* POSIX-standard 'x' header. */
			if (seen_headers & seen_x_header) {
				return (ARCHIVE_FATAL);
			}
			seen_headers |= seen_x_header;
			a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
			a->archive.archive_format_name = "POSIX pax interchange format";
			err2 = header_pax_extension(a, tar, entry, h, unconsumed);
			break;
		default: /* Regular header: Legacy tar, GNU tar, or ustar */
			gnuheader = (const struct archive_entry_header_gnutar *)h;
			if (memcmp(gnuheader->magic, "ustar  \0", 8) == 0) {
				a->archive.archive_format = ARCHIVE_FORMAT_TAR_GNUTAR;
				a->archive.archive_format_name = "GNU tar format";
				err2 = header_gnutar(a, tar, entry, h, unconsumed);
			} else if (memcmp(header->magic, "ustar", 5) == 0) {
				if (a->archive.archive_format != ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE) {
					a->archive.archive_format = ARCHIVE_FORMAT_TAR_USTAR;
					a->archive.archive_format_name = "POSIX ustar format";
				}
				err2 = header_ustar(a, tar, entry, h);
			} else {
				a->archive.archive_format = ARCHIVE_FORMAT_TAR;
				a->archive.archive_format_name = "tar (non-POSIX)";
				err2 = header_old_tar(a, tar, entry, h);
			}
			err = err_combine(err, err2);
			/* We return warnings or success as-is.  Anything else is fatal. */
			if (err < ARCHIVE_WARN) {
				return (ARCHIVE_FATAL);
			}
			/* Filename of the form `._filename` is an AppleDouble
			 * extension entry.  The body is the macOS metadata blob;
			 * this is followed by another entry with the actual
			 * regular file data.
			 * This design has two drawbacks:
			 * = it's brittle; you might just have a file with such a name
			 * = it duplicates any long pathname extensions
			 *
			 * TODO: This probably shouldn't be here at all.  Consider
			 * just returning the contents as a regular entry here and
			 * then dealing with it when we write data to disk.
			 */
			if (tar->process_mac_extensions
			    && ((seen_headers & seen_mac_metadata) == 0)
			    && is_mac_metadata_entry(entry)) {
				err2 = read_mac_metadata_blob(a, entry, unconsumed);
				if (err2 < ARCHIVE_WARN) {
					return (ARCHIVE_FATAL);
				}
				err = err_combine(err, err2);
				/* Note: Other headers can appear again. */
				seen_headers = seen_mac_metadata;
				break;
			}

			/* Reconcile GNU sparse attributes */
			if (tar->sparse_gnu_attributes_seen) {
				/* Only 'S' (GNU sparse) and ustar '0' regular files can be sparse */
				if (tar->filetype != 'S' && tar->filetype != '0') {
					archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
							  "Non-regular file cannot be sparse");
					return (ARCHIVE_WARN);
				} else if (tar->sparse_gnu_major == 0 &&
				    tar->sparse_gnu_minor == 0) {
					/* Sparse map already parsed from 'x' header */
				} else if (tar->sparse_gnu_major == 0 &&
				    tar->sparse_gnu_minor == 1) {
					/* Sparse map already parsed from 'x' header */
				} else if (tar->sparse_gnu_major == 1 &&
				    tar->sparse_gnu_minor == 0) {
					/* Sparse map is prepended to file contents */
					ssize_t bytes_read;
					bytes_read = gnu_sparse_10_read(a, tar, unconsumed);
					if (bytes_read < 0)
						return ((int)bytes_read);
					tar->entry_bytes_remaining -= bytes_read;
				} else {
					archive_set_error(&a->archive,
							  ARCHIVE_ERRNO_MISC,
							  "Unrecognized GNU sparse file format");
					return (ARCHIVE_WARN);
				}
			}
			return (err);
		}

		/* We're between headers ... */
		err = err_combine(err, err2);
		if (err == ARCHIVE_FATAL)
			return (err);

		/* The GNU volume header and the pax `g` global header
		 * are both allowed to be the only header in an
		 * archive.  If we've seen any other header, a
		 * following EOF is fatal. */
		if ((seen_headers & ~seen_V_header & ~seen_g_header) != 0) {
			eof_fatal = 1;
		}
	}
	return (ARCHIVE_FATAL);
}

/*

	if (sum == check)
		return (1);

#if DONT_FAIL_ON_CRC_ERROR
	/* Speed up fuzzing by pretending the checksum is always right. */
	return (1);
#else
	return (0);
#endif
}

/*

    struct archive_entry *entry, const void *h, size_t *unconsumed)
{
	const struct archive_entry_header_ustar *header;
	struct archive_string	 acl_text;
	size_t size;
	int err, acl_type;
	int64_t type;
	char *acl, *p;

	/*
	 * read_body_to_string adds a NUL terminator, but we need a little
	 * more to make sure that we don't overrun acl_text later.
	 */
	header = (const struct archive_entry_header_ustar *)h;
	size = (size_t)tar_atol(header->size, sizeof(header->size));
	archive_string_init(&acl_text);
	err = read_body_to_string(a, tar, &acl_text, h, unconsumed);
	if (err != ARCHIVE_OK) {
		archive_string_free(&acl_text);
	/* Recursively read next header */
	err = tar_read_header(a, tar, entry, unconsumed);
	if ((err != ARCHIVE_OK) && (err != ARCHIVE_WARN))
		return (err);
	}

	/* TODO: Examine the first characters to see if this
	 * is an AIX ACL descriptor.  We'll likely never support

	 * we do see them. */

	/* Leading octal number indicates ACL type and number of entries. */
	p = acl = acl_text.s;
	type = 0;
	while (*p != '\0' && p < acl + size) {
		if (*p < '0' || *p > '7') {
			archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
			    "Malformed Solaris ACL attribute (invalid digit)");
			archive_string_free(&acl_text);
			return(ARCHIVE_WARN);
		}
		type <<= 3;

		if (type > 077777777) {
			archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
			    "Malformed Solaris ACL attribute (count too large)");
			archive_string_free(&acl_text);
			return (ARCHIVE_WARN);
		}
		p++;

		archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
		    "Malformed Solaris ACL attribute (unsupported type %o)",
		    (int)type);
		archive_string_free(&acl_text);
		return (ARCHIVE_WARN);
	}
	p++;

	if (p >= acl + size) {
		archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
		    "Malformed Solaris ACL attribute (body overflow)");
		archive_string_free(&acl_text);
		return(ARCHIVE_WARN);
	}


	if (tar->sconv_acl == NULL) {
		tar->sconv_acl = archive_string_conversion_from_charset(
		    &(a->archive), "UTF-8", 1);
		if (tar->sconv_acl == NULL) {
			archive_string_free(&acl_text);
			return (ARCHIVE_FATAL);
		}
	}
	archive_strncpy(&(tar->localname), acl, p - acl);
	err = archive_acl_from_text_l(archive_entry_acl(entry),
	    tar->localname.s, acl_type, tar->sconv_acl);
	/* Workaround: Force perm_is_set() to be correct */
	/* If this bit were stored in the ACL, this wouldn't be needed */
	archive_entry_set_perm(entry, archive_entry_perm(entry));
	if (err != ARCHIVE_OK) {
		if (errno == ENOMEM) {
			archive_set_error(&a->archive, ENOMEM,

			archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
			    "Malformed Solaris ACL attribute (unparsable)");
	}
	archive_string_free(&acl_text);
	return (err);
}


 * Interpret 'K' long linkname header.
 */
static int
header_gnu_longlink(struct archive_read *a, struct tar *tar,
    struct archive_entry *entry, const void *h, size_t *unconsumed)
{
	int err;

	struct archive_string linkpath;
	archive_string_init(&linkpath);
	err = read_body_to_string(a, tar, &linkpath, h, unconsumed);
	archive_entry_set_link(entry, linkpath.s);
	archive_string_free(&linkpath);
	return (err);
	/* Set symlink if symlink already set, else hardlink. */
	archive_entry_copy_link(entry, tar->longlink.s);
	return (ARCHIVE_OK);
}

static int

 * Interpret 'L' long filename header.
 */
static int
header_gnu_longname(struct archive_read *a, struct tar *tar,
    struct archive_entry *entry, const void *h, size_t *unconsumed)
{
	int err;
	struct archive_string longname;

	archive_string_init(&longname);
	err = read_body_to_string(a, tar, &longname, h, unconsumed);
	if (err == ARCHIVE_OK) {
		if (archive_entry_copy_pathname_l(entry, longname.s,
		    archive_strlen(&longname), tar->sconv) != 0)
			err = set_conversion_failed_error(a, tar->sconv, "Pathname");
	}
	archive_string_free(&longname);
	    archive_strlen(&(tar->longname)), tar->sconv) != 0)
		err = set_conversion_failed_error(a, tar->sconv, "Pathname");
	return (err);
}


/*
 * Interpret 'V' GNU tar volume header.
 */

header_volume(struct archive_read *a, struct tar *tar,
    struct archive_entry *entry, const void *h, size_t *unconsumed)
{
	const struct archive_entry_header_ustar *header;
	int64_t size, to_consume;

	(void)a; /* UNUSED */
	(void)tar; /* UNUSED */
	(void)entry; /* UNUSED */

	header = (const struct archive_entry_header_ustar *)h;
	size = tar_atol(header->size, sizeof(header->size));
	if (size > (int64_t)pathname_limit) {
		return (ARCHIVE_FATAL);
	}
	to_consume = ((size + 511) & ~511);
	*unconsumed += to_consume;
	return (ARCHIVE_OK);
}

/*
 * Read the next `size` bytes into the provided string.
 * Null-terminate the string.
 */
static int
read_bytes_to_string(struct archive_read *a,
		     struct archive_string *as, size_t size,
		     size_t *unconsumed) {
	int64_t size;
	const struct archive_entry_header_ustar *header;
	const void *src;

	(void)tar; /* UNUSED */
	header = (const struct archive_entry_header_ustar *)h;
	size  = tar_atol(header->size, sizeof(header->size));
	if ((size > 1048576) || (size < 0)) {
		archive_set_error(&a->archive, EINVAL,
		    "Special header too large");
		return (ARCHIVE_FATAL);
	}

	/* Fail if we can't make our buffer big enough. */
	if (archive_string_ensure(as, (size_t)size+1) == NULL) {
		archive_set_error(&a->archive, ENOMEM,

	tar_flush_unconsumed(a, unconsumed);

	/* Read the body into the string. */
	src = __archive_read_ahead(a, size, NULL);
	src = __archive_read_ahead(a, *unconsumed, NULL);
	if (src == NULL) {
		archive_set_error(&a->archive, EINVAL,
		    "Truncated archive"
		    " detected while reading metadata");
		*unconsumed = 0;
		return (ARCHIVE_FATAL);
	}
	memcpy(as->s, src, (size_t)size);
	as->s[size] = '\0';
	as->length = (size_t)size;
	*unconsumed += size;
	return (ARCHIVE_OK);
}

/*
 * Read body of an archive entry into an archive_string object.
 */
static int
read_body_to_string(struct archive_read *a, struct tar *tar,
    struct archive_string *as, const void *h, size_t *unconsumed)
{
	int64_t size;
	const struct archive_entry_header_ustar *header;
	int r;

	(void)tar; /* UNUSED */
	header = (const struct archive_entry_header_ustar *)h;
	size  = tar_atol(header->size, sizeof(header->size));
	if (size > entry_limit) {
		return (ARCHIVE_FATAL);
	}
	if ((size > (int64_t)pathname_limit) || (size < 0)) {
		archive_string_empty(as);
		int64_t to_consume = ((size + 511) & ~511);
		if (to_consume != __archive_read_consume(a, to_consume)) {
			return (ARCHIVE_FATAL);
		}
		archive_set_error(&a->archive, EINVAL,
		    "Special header too large: %d > 1MiB",
		    (int)size);
		return (ARCHIVE_WARN);
	}
	r = read_bytes_to_string(a, as, size, unconsumed);
	*unconsumed += 0x1ff & (-size);
	return(r);
}

/*
 * Parse out common header elements.
 *

    struct archive_entry *entry, const void *h)
{
	const struct archive_entry_header_ustar	*header;
	const char *existing_linkpath;
	const wchar_t *existing_wcs_linkpath;
	int     err = ARCHIVE_OK;

	header = (const struct archive_entry_header_ustar *)h;
	if (header->linkname[0])
		archive_strncpy(&(tar->entry_linkpath),
		    header->linkname, sizeof(header->linkname));
	else
		archive_string_empty(&(tar->entry_linkpath));

	/* Parse out the numeric fields (all are octal) */

	/* Split mode handling: Set filetype always, perm only if not already set */
	archive_entry_set_filetype(entry,
	    (mode_t)tar_atol(header->mode, sizeof(header->mode)));
	if (!archive_entry_perm_is_set(entry)) {
		archive_entry_set_perm(entry,
			(mode_t)tar_atol(header->mode, sizeof(header->mode)));
	}
	if (!archive_entry_uid_is_set(entry)) {
		archive_entry_set_uid(entry, tar_atol(header->uid, sizeof(header->uid)));
	}
	if (!archive_entry_gid_is_set(entry)) {
		archive_entry_set_gid(entry, tar_atol(header->gid, sizeof(header->gid)));
	}

	tar->entry_bytes_remaining = tar_atol(header->size, sizeof(header->size));
	if (tar->entry_bytes_remaining < 0) {
		tar->entry_bytes_remaining = 0;

		    "Tar entry has negative size");
		return (ARCHIVE_FATAL);
	}
	if (tar->entry_bytes_remaining > entry_limit) {
		/* Note: tar_atol returns INT64_MAX on overflow */
		tar->entry_bytes_remaining = 0;
		archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
		    "Tar entry size overflow");
		return (ARCHIVE_FATAL);
	}
	if (!tar->realsize_override) {
		tar->realsize = tar->entry_bytes_remaining;
	}
	archive_entry_set_size(entry, tar->realsize);

	if (!archive_entry_mtime_is_set(entry)) {
		archive_entry_set_mtime(entry, tar_atol(header->mtime, sizeof(header->mtime)), 0);
	}

	/* Handle the tar type flag appropriately. */
	tar->filetype = header->typeflag[0];

	/*
	 * TODO: If the linkpath came from Pax extension header, then
	 * we should obey the hdrcharset_utf8 flag when converting these.
	 */
	switch (tar->filetype) {
	case '1': /* Hard link */
		archive_entry_set_link_to_hardlink(entry);
		existing_wcs_linkpath = archive_entry_hardlink_w(entry);
		existing_linkpath = archive_entry_hardlink(entry);
		if ((existing_linkpath == NULL || existing_linkpath[0] == '\0')
		    && (existing_wcs_linkpath == NULL || existing_wcs_linkpath[0] == '\0')) {
			struct archive_string linkpath;
			archive_string_init(&linkpath);
			archive_strncpy(&linkpath,
					header->linkname, sizeof(header->linkname));
			if (archive_entry_copy_hardlink_l(entry, linkpath.s,
							  archive_strlen(&linkpath), tar->sconv) != 0) {
				err = set_conversion_failed_error(a, tar->sconv,
								  "Linkname");
				if (err == ARCHIVE_FATAL) {
					archive_string_free(&linkpath);
					return (err);
				}
			}
			archive_string_free(&linkpath);
		}
		/*
		 * The following may seem odd, but: Technically, tar

		 */
		break;
	case '2': /* Symlink */
		archive_entry_set_link_to_symlink(entry);
		existing_wcs_linkpath = archive_entry_symlink_w(entry);
		existing_linkpath = archive_entry_symlink(entry);
		if ((existing_linkpath == NULL || existing_linkpath[0] == '\0')
		    && (existing_wcs_linkpath == NULL || existing_wcs_linkpath[0] == '\0')) {
			struct archive_string linkpath;
			archive_string_init(&linkpath);
			archive_strncpy(&linkpath,
					header->linkname, sizeof(header->linkname));
			if (archive_entry_copy_symlink_l(entry, linkpath.s,
			    archive_strlen(&linkpath), tar->sconv) != 0) {
				err = set_conversion_failed_error(a, tar->sconv,
				    "Linkname");
				if (err == ARCHIVE_FATAL) {
					archive_string_free(&linkpath);
					return (err);
				}
			}
			archive_string_free(&linkpath);
		}
		archive_entry_set_filetype(entry, AE_IFLNK);
		archive_entry_set_size(entry, 0);
		tar->entry_bytes_remaining = 0;
		if (archive_entry_copy_symlink_l(entry, tar->entry_linkpath.s,
		    archive_strlen(&(tar->entry_linkpath)), tar->sconv) != 0) {
			err = set_conversion_failed_error(a, tar->sconv,
			    "Linkname");
			if (err == ARCHIVE_FATAL)
				return (err);
		}
		break;
	case '3': /* Character device */
		archive_entry_set_filetype(entry, AE_IFCHR);

		 * sparse information in the extended area.
		 */
		/* FALLTHROUGH */
	case '0': /* ustar "regular" file */
		/*
		 * Enable sparse file "read" support only for regular
		 * files and explicit GNU sparse files.  However, we
		 * don't allow non-standard file types to be sparse.
		 */
		tar->sparse_allowed = 1;
		/* FALLTHROUGH */
	default: /* Non-standard file types */
		/*
		 * Per POSIX: non-recognized types should always be
		 * treated as regular files.

	const struct archive_entry_header_ustar	*header;
	int err = ARCHIVE_OK, err2;

	/*
	 * Copy filename over (to ensure null termination).
	 * Skip if pathname was already set e.g. by header_gnu_longname()
	 */
	header = (const struct archive_entry_header_ustar *)h;

	const char *existing_pathname = archive_entry_pathname(entry);
	const wchar_t *existing_wcs_pathname = archive_entry_pathname_w(entry);
	if ((existing_pathname == NULL || existing_pathname[0] == '\0')
	    && (existing_wcs_pathname == NULL || existing_wcs_pathname[0] == '\0') &&
	    archive_entry_copy_pathname_l(entry,
	    header->name, sizeof(header->name), tar->sconv) != 0) {
		err = set_conversion_failed_error(a, tar->sconv, "Pathname");
		if (err == ARCHIVE_FATAL)

}

/*
 * Is this likely an AppleDouble extension?
 * if there is one.
 */
static int
is_mac_metadata_entry(struct archive_entry *entry) {
    struct archive_entry *entry, const void *h, size_t *unconsumed)
{
	int64_t size;
	size_t msize;
	const void *data;
	const char *p, *name;
	const wchar_t *wp, *wname;

	(void)h; /* UNUSED */

	wname = wp = archive_entry_pathname_w(entry);
	if (wp != NULL) {
		/* Find the last path element. */

		 * If last path element starts with "._", then
		 * this is a Mac extension.
		 */
		if (wname[0] == L'.' && wname[1] == L'_' && wname[2] != L'\0')
			return 1;
	} else {
		/* Find the last path element. */
		name = p = archive_entry_pathname(entry);

		 * If last path element starts with "._", then
		 * this is a Mac extension.
		 */
		if (name[0] == '.' && name[1] == '_' && name[2] != '\0')
			return 1;
	}
	/* Not a mac extension */
	return 0;
}

/*
 * Read a Mac AppleDouble-encoded blob of file metadata,
 * if there is one.
 *
 * TODO: In Libarchive 4, we should consider ripping this
 * out -- instead, return a file starting with `._` as
 * a regular file and let the client (or archive_write logic)
 * handle it.
 */
static int
read_mac_metadata_blob(struct archive_read *a,
    struct archive_entry *entry, size_t *unconsumed)
{
	int64_t size;
	size_t msize;
	const void *data;

 	/* Read the body as a Mac OS metadata blob. */
	size = archive_entry_size(entry);

		return (ARCHIVE_FATAL);
	}

	/* TODO: Should this merely skip the overlarge entry and
	 * WARN?  Or is xattr_limit sufficiently large that we can
	 * safely assume anything larger is malicious? */
	if (size > (int64_t)xattr_limit) {
		archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
		    "Oversized AppleDouble extension has size %llu > %llu",
		    (unsigned long long)size,
		    (unsigned long long)xattr_limit);
		return (ARCHIVE_FATAL);
	}

	/*
	 * TODO: Look beyond the body here to peek at the next header.
	 * If it's a regular header (not an extension header)

	 * Q: Is the above idea really possible?  Even
	 * when there are GNU or pax extension entries?
	 */
	tar_flush_unconsumed(a, unconsumed);
	data = __archive_read_ahead(a, msize, NULL);
	if (data == NULL) {
		archive_set_error(&a->archive, EINVAL,
		    "Truncated archive"
		    " detected while reading macOS metadata");
		*unconsumed = 0;
		return (ARCHIVE_FATAL);
	}
	archive_entry_clear(entry);
	archive_entry_copy_mac_metadata(entry, data, msize);
	*unconsumed = (msize + 511) & ~ 511;
	return (ARCHIVE_OK);
	return (tar_read_header(a, tar, entry, unconsumed));
}

/*

header_pax_global(struct archive_read *a, struct tar *tar,
    struct archive_entry *entry, const void *h, size_t *unconsumed)
{
	const struct archive_entry_header_ustar *header;
	int64_t size, to_consume;

	(void)a; /* UNUSED */
	(void)tar; /* UNUSED */
	(void)entry; /* UNUSED */

	header = (const struct archive_entry_header_ustar *)h;
	size = tar_atol(header->size, sizeof(header->size));
	if (size > entry_limit) {
		return (ARCHIVE_FATAL);
	}
	to_consume = ((size + 511) & ~511);
	*unconsumed += to_consume;
	return (ARCHIVE_OK);
}

/*
 * Parse a file header for a Posix "ustar" archive entry.  This also
 * handles "pax" or "extended ustar" entries.
 *
 * In order to correctly handle pax attributes (which precede this),
 * we have to skip parsing any field for which the entry already has
 * contents.
 */
static int
header_ustar(struct archive_read *a, struct tar *tar,
    struct archive_entry *entry, const void *h)
{
	const struct archive_entry_header_ustar	*header;
	struct archive_string as;
	int err = ARCHIVE_OK, r;
	if (err != ARCHIVE_OK)
		return (err);

	/* Parse the next header. */
	err = tar_read_header(a, tar, entry, unconsumed);
	if ((err != ARCHIVE_OK) && (err != ARCHIVE_WARN))
		return (err);

	/*
	 * TODO: Parse global/default options into 'entry' struct here
	 * before handling file-specific options.
	 *
	 * This design (parse standard header, then overwrite with pax
	 * extended attribute data) usually works well, but isn't ideal;
	 * it would be better to parse the pax extended attributes first
	 * and then skip any fields in the standard header that were
	 * defined in the pax header.
	 */
	err2 = pax_header(a, tar, entry, &tar->pax_header);
	err =  err_combine(err, err2);
	tar->entry_padding = 0x1ff & (-tar->entry_bytes_remaining);
	return (err);
}


/*
 * Parse a file header for a Posix "ustar" archive entry.  This also
 * handles "pax" or "extended ustar" entries.
 */
static int
header_ustar(struct archive_read *a, struct tar *tar,
    struct archive_entry *entry, const void *h)
{
	const struct archive_entry_header_ustar	*header;
	struct archive_string *as;
	int err = ARCHIVE_OK, r;

	header = (const struct archive_entry_header_ustar *)h;

	/* Copy name into an internal buffer to ensure null-termination. */
	const char *existing_pathname = archive_entry_pathname(entry);
	const wchar_t *existing_wcs_pathname = archive_entry_pathname_w(entry);
	if ((existing_pathname == NULL || existing_pathname[0] == '\0')
	    && (existing_wcs_pathname == NULL || existing_wcs_pathname[0] == '\0')) {
		archive_string_init(&as);
		if (header->prefix[0]) {
			archive_strncpy(&as, header->prefix, sizeof(header->prefix));
			if (as.s[archive_strlen(&as) - 1] != '/')
				archive_strappend_char(&as, '/');
			archive_strncat(&as, header->name, sizeof(header->name));
		} else {
			archive_strncpy(&as, header->name, sizeof(header->name));
		}
		if (archive_entry_copy_pathname_l(entry, as.s, archive_strlen(&as),
		    tar->sconv) != 0) {
			err = set_conversion_failed_error(a, tar->sconv, "Pathname");
			if (err == ARCHIVE_FATAL)
				return (err);
		}
		archive_string_free(&as);
	}

	/* Handle rest of common fields. */

		err = r;

	/* Handle POSIX ustar fields. */
	const char *existing_uname = archive_entry_uname(entry);
	if (existing_uname == NULL || existing_uname[0] == '\0') {
		if (archive_entry_copy_uname_l(entry,
		    header->uname, sizeof(header->uname), tar->sconv) != 0) {
			err = set_conversion_failed_error(a, tar->sconv, "Uname");
			if (err == ARCHIVE_FATAL)
				return (err);
		}
	}

	const char *existing_gname = archive_entry_gname(entry);
	if (existing_gname == NULL || existing_gname[0] == '\0') {
		if (archive_entry_copy_gname_l(entry,
		    header->gname, sizeof(header->gname), tar->sconv) != 0) {
			err = set_conversion_failed_error(a, tar->sconv, "Gname");
			if (err == ARCHIVE_FATAL)
				return (err);
		}
	}

	/* Parse out device numbers only for char and block specials. */
	if (header->typeflag[0] == '3' || header->typeflag[0] == '4') {
		if (!archive_entry_rdev_is_set(entry)) {
			archive_entry_set_rdevmajor(entry, (dev_t)
			    tar_atol(header->rdevmajor, sizeof(header->rdevmajor)));
			archive_entry_set_rdevminor(entry, (dev_t)
			    tar_atol(header->rdevminor, sizeof(header->rdevminor)));
		}
	} else {
		archive_entry_set_rdev(entry, 0);
	}

	tar->entry_padding = 0x1ff & (-tar->entry_bytes_remaining);

	return (err);
}


/*
 * Parse the pax extended attributes record.
 *
 * Returns non-zero if there's an error in the data.
 */
static int
header_pax_extension(struct archive_read *a, struct tar *tar,
    struct archive_entry *entry, const void *h, size_t *unconsumed)
{
	/* Sanity checks: The largest `x` body I've ever heard of was
	 * a little over 4MB.  So I doubt there has ever been a
	 * well-formed archive with an `x` body over 1GiB.  Similarly,
	 * it seems plausible that no single attribute has ever been
	 * larger than 100MB.  So if we see a larger value here, it's
	 * almost certainly a sign of a corrupted/malicious archive. */

	/* Maximum sane size for extension body: 1 GiB */
	/* This cannot be raised to larger than 8GiB without
	 * exceeding the maximum size for a standard ustar
	 * entry. */
	const int64_t ext_size_limit = 1024 * 1024 * (int64_t)1024;
	/* Maximum size for a single line/attr: 100 million characters */
	/* This cannot be raised to more than 2GiB without exceeding
	 * a `size_t` on 32-bit platforms. */
	const size_t max_parsed_line_length = 99999999ULL;
	/* Largest attribute prolog:  size + name. */
	const size_t max_size_name = 512;

	/* Size and padding of the full extension body */
	int64_t ext_size, ext_padding;
	size_t line_length, value_length, name_length;
	ssize_t to_read, did_read;
	const struct archive_entry_header_ustar *header;
	const char *p, *attr_start, *name_start;
	struct archive_string_conv *sconv;
	struct archive_string *pas = NULL;
	struct archive_string attr_name;
	int err = ARCHIVE_OK, r;

	header = (const struct archive_entry_header_ustar *)h;
	ext_size  = tar_atol(header->size, sizeof(header->size));
	if (ext_size > entry_limit) {
		return (ARCHIVE_FATAL);
	}
	if (ext_size < 0) {
	  archive_set_error(&a->archive, EINVAL,
			    "pax extension header has invalid size: %lld",
			    (long long)ext_size);
	  return (ARCHIVE_FATAL);
	}

	ext_padding = 0x1ff & (-ext_size);
	if (ext_size > ext_size_limit) {
		/* Consume the pax extension body and return an error */
		if (ext_size + ext_padding != __archive_read_consume(a, ext_size + ext_padding)) {
			return (ARCHIVE_FATAL);
		}
		archive_set_error(&a->archive, EINVAL,
		    "Ignoring oversized pax extensions: %d > %d",
		    (int)ext_size, (int)ext_size_limit);
		return (ARCHIVE_WARN);
	}
	tar_flush_unconsumed(a, unconsumed);

	/* Parse the size/name of each pax attribute in the body */
	archive_string_init(&attr_name);
	while (ext_size > 0) {
		/* Read enough bytes to parse the size/name of the next attribute */
		to_read = max_size_name;
		if (to_read > ext_size) {
			to_read = ext_size;
		}
		p = __archive_read_ahead(a, to_read, &did_read);
		if (p == NULL) { /* EOF */
			archive_set_error(&a->archive, EINVAL,
					  "Truncated tar archive"
					  " detected while reading pax attribute name");
			return (ARCHIVE_FATAL);
		}
		if (did_read > ext_size) {
			did_read = ext_size;
		}

		/* Parse size of attribute */
		line_length = 0;
		attr_start = p;
		while (1) {
			if (p >= attr_start + did_read) {
				archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
						  "Ignoring malformed pax attributes: overlarge attribute size field");
				*unconsumed += ext_size + ext_padding;
				return (ARCHIVE_WARN);
			}
			if (*p == ' ') {
				p++;
				l--;
				break;
			}
			if (*p < '0' || *p > '9') {
				archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
						  "Ignoring malformed pax attributes: malformed attribute size field");
				*unconsumed += ext_size + ext_padding;
				return (ARCHIVE_WARN);
			}
			line_length *= 10;
			line_length += *p - '0';
			if (line_length > max_parsed_line_length) {
				archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
						  "Ignoring malformed pax attribute: size > %lld",
						  (long long)max_parsed_line_length);
				*unconsumed += ext_size + ext_padding;
				return (ARCHIVE_WARN);
			}
			p++;
			l--;
		}

		if ((int64_t)line_length > ext_size) {
				archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
						  "Ignoring malformed pax attribute:  %lld > %lld",
						  (long long)line_length, (long long)ext_size);
				*unconsumed += ext_size + ext_padding;
				return (ARCHIVE_WARN);
		    || line_length < 1
		    || attr[line_length - 1] != '\n')
		{
			archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
			    "Ignoring malformed pax extended attribute");
			return (ARCHIVE_WARN);
		}

		/* Parse name of attribute */
		if (p >= attr_start + did_read
		    || p >= attr_start + line_length
		    || *p == '=') {
		key = p;
		if (key[0] == '=')
			return (-1);
		while (*p && *p != '=')
			++p;
		if (*p == '\0') {
			archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
					  "Ignoring malformed pax attributes: empty name found");
			*unconsumed += ext_size + ext_padding;
			return (ARCHIVE_WARN);
		}
		name_start = p;
		while (1) {
			if (p >= attr_start + did_read || p >= attr_start + line_length) {
				archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
						  "Ignoring malformed pax attributes: overlarge attribute name");
				*unconsumed += ext_size + ext_padding;
				return (ARCHIVE_WARN);
			}
			if (*p == '=') {
				break;
			}
			p++;
		}
		name_length = p - name_start;
		p++; // Skip '='

		// Save the name before we consume it
		archive_strncpy(&attr_name, name_start, name_length);

		ext_size -= p - attr_start;
		value_length = line_length - (p - attr_start);

		/* Consume size, name, and `=` */
		*unconsumed += p - attr_start;
		tar_flush_unconsumed(a, unconsumed);

		/* pax_attribute will consume value_length - 1 */
		r = pax_attribute(a, tar, entry, attr_name.s, archive_strlen(&attr_name), value_length - 1, unconsumed);
		ext_size -= value_length - 1;

		// Release the allocated attr_name (either here or before every return in this function)
		archive_string_free(&attr_name);

		if (r < ARCHIVE_WARN) {
			*unconsumed += ext_size + ext_padding;
			return (r);
		}
		err = err_combine(err, r);

		/* Consume the `\n` that follows the pax attribute value. */
		tar_flush_unconsumed(a, unconsumed);
		p = __archive_read_ahead(a, 1, &did_read);
		if (p == NULL) {
			archive_set_error(&a->archive, EINVAL,
					  "Truncated tar archive"
					  " detected while completing pax attribute");
			return (ARCHIVE_FATAL);
		}
		if (p[0] != '\n') {
			archive_set_error(&a->archive, EINVAL,
					  "Malformed pax attributes");
			*unconsumed += ext_size + ext_padding;
			return (ARCHIVE_WARN);
		}
		ext_size -= 1;
		*unconsumed += 1;
		tar_flush_unconsumed(a, unconsumed);
	}
	*unconsumed += ext_size + ext_padding;

	/*
	 * Some PAX values -- pathname, linkpath, uname, gname --
	 * can't be copied into the entry until we know the character
	 * set to use:
	 * when the hdrcharset attribute(in PAX header) is BINARY because
	 * we respect the charset described in PAX header and BINARY also
	 * means that metadata(filename,uname and gname) character-set
	 * is unknown.
	 */
	if (!tar->pax_hdrcharset_utf8)
		/* PAX specified "BINARY", so use the default charset */
		sconv = tar->opt_sconv;
	else {
		/* PAX default UTF-8 */
		sconv = archive_string_conversion_from_charset(
		    &(a->archive), "UTF-8", 1);
		if (sconv == NULL)

			    SCONV_SET_OPT_UTF8_LIBARCHIVE2X);
	}

	/* Pathname */
	pas = NULL;
	if (archive_strlen(&(tar->entry_pathname_override)) > 0) {
		/* Prefer GNU.sparse.name attribute if present */
		/* GNU sparse files store a fake name under the standard
		 * "pathname" key. */
		pas = &(tar->entry_pathname_override);
	} else if (archive_strlen(&(tar->entry_pathname)) > 0) {
		/* Use standard "pathname" PAX extension */
		pas = &(tar->entry_pathname);
	}
	if (pas != NULL) {
		if (archive_entry_copy_pathname_l(entry, pas->s,
		    archive_strlen(pas), sconv) != 0) {
			err = set_conversion_failed_error(a, sconv, "Pathname");
			if (err == ARCHIVE_FATAL)
				return (err);
			/* Use raw name without conversion */
			archive_entry_copy_pathname(entry, pas->s);
		}
	}
	/* Uname */
	if (archive_strlen(&(tar->entry_uname)) > 0) {
		if (archive_entry_copy_uname_l(entry, tar->entry_uname.s,
		    archive_strlen(&(tar->entry_uname)), sconv) != 0) {
			err = set_conversion_failed_error(a, sconv, "Uname");
			if (err == ARCHIVE_FATAL)
				return (err);
			/* Use raw name without conversion */
			archive_entry_copy_uname(entry, tar->entry_uname.s);
		}
	}
	/* Gname */
	if (archive_strlen(&(tar->entry_gname)) > 0) {
		if (archive_entry_copy_gname_l(entry, tar->entry_gname.s,
		    archive_strlen(&(tar->entry_gname)), sconv) != 0) {
			err = set_conversion_failed_error(a, sconv, "Gname");
			if (err == ARCHIVE_FATAL)
				return (err);
			/* Use raw name without conversion */
			archive_entry_copy_gname(entry, tar->entry_gname.s);
		}
	}
	/* Linkpath */
	if (archive_strlen(&(tar->entry_linkpath)) > 0) {
		if (archive_entry_copy_link_l(entry, tar->entry_linkpath.s,
		    archive_strlen(&(tar->entry_linkpath)), sconv) != 0) {
			err = set_conversion_failed_error(a, sconv, "Linkpath");
			if (err == ARCHIVE_FATAL)
				return (err);
			/* Use raw name without conversion */
			archive_entry_copy_link(entry, tar->entry_linkpath.s);
		}
	}

	/* Extension may have given us a corrected `entry_bytes_remaining` for
	 * the main entry; update the padding appropriately. */
	tar->entry_padding = 0x1ff & (-tar->entry_bytes_remaining);
	 * Since we're supposed to not care about the order, we
	 * have no choice but to store all of the various filenames
	 * we find and figure it all out afterwards.  This is the
	 * figuring out part.
	 */
	as = NULL;
	if (archive_strlen(&(tar->entry_pathname_override)) > 0)
		as = &(tar->entry_pathname_override);
	else if (archive_strlen(&(tar->entry_pathname)) > 0)
		as = &(tar->entry_pathname);
	if (as != NULL) {
		if (archive_entry_copy_pathname_l(entry, as->s,
		    archive_strlen(as), sconv) != 0) {
			err = set_conversion_failed_error(a, sconv, "Pathname");
			if (err == ARCHIVE_FATAL)
				return (err);
			/* Use a converted an original name. */
			archive_entry_copy_pathname(entry, as->s);
		}
	}
	if (archive_strlen(&(tar->entry_uname)) > 0) {
		if (archive_entry_copy_uname_l(entry, tar->entry_uname.s,
		    archive_strlen(&(tar->entry_uname)), sconv) != 0) {
			err = set_conversion_failed_error(a, sconv, "Uname");
			if (err == ARCHIVE_FATAL)
				return (err);
			/* Use a converted an original name. */
			archive_entry_copy_uname(entry, tar->entry_uname.s);
		}
	}
	return (err);
}

static int
pax_attribute_LIBARCHIVE_xattr(struct archive_entry *entry,
	const char *name, size_t name_length, const char *value, size_t value_length)
{
	char *name_decoded;
	void *value_decoded;
	size_t value_len;

	if (name_length < 1)
		return 3;

	name += 17;

	/* URL-decode name */
	name_decoded = url_decode(name, name_length);
	if (name_decoded == NULL)
		return 2;

	/* Base-64 decode value */
	value_decoded = base64_decode(value, value_length, &value_len);
	if (value_decoded == NULL) {
		free(name_decoded);
		return 1;

}

static int
pax_attribute_SCHILY_xattr(struct archive_entry *entry,
	const char *name, size_t name_length, const char *value, size_t value_length)
{
	if (name_length < 1 || name_length > 128) {
		return 1;
	}

	char * null_terminated_name = malloc(name_length + 1);
	if (null_terminated_name != NULL) {
		memcpy(null_terminated_name, name, name_length);
		null_terminated_name[name_length] = '\0';
		archive_entry_xattr_add_entry(entry, null_terminated_name, value, value_length);
		free(null_terminated_name);
	}

	return 0;
}

static int
pax_attribute_RHT_security_selinux(struct archive_entry *entry,
	const char *value, size_t value_length)
{
	archive_entry_xattr_add_entry(entry, "security.selinux",

}

static int
pax_attribute_SCHILY_acl(struct archive_read *a, struct tar *tar,
	struct archive_entry *entry, size_t value_length, int type)
{
	int r;
	const char *p;
	const char* errstr;

	switch (type) {

			return (ARCHIVE_FATAL);
	}

	if (value_length > acl_limit) {
		__archive_read_consume(a, value_length);
		archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
				  "Unreasonably large ACL: %d > %d",
				  (int)value_length, (int)acl_limit);
		return (ARCHIVE_WARN);
	}

	p = __archive_read_ahead(a, value_length, NULL);
	if (p == NULL) {
		archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
				  "Truncated tar archive "
				  "detected while reading ACL data");
		return (ARCHIVE_FATAL);
	}

	r = archive_acl_from_text_nl(archive_entry_acl(entry), p, value_length,
	    type, tar->sconv_acl);
	__archive_read_consume(a, value_length);
	/* Workaround: Force perm_is_set() to be correct */
	/* If this bit were stored in the ACL, this wouldn't be needed */
	archive_entry_set_perm(entry, archive_entry_perm(entry));
	if (r != ARCHIVE_OK) {
		if (r == ARCHIVE_FATAL) {
			archive_set_error(&a->archive, ENOMEM,

	return (r);
}

static int
pax_attribute_read_time(struct archive_read *a, size_t value_length, int64_t *ps, long *pn, size_t *unconsumed) {
	struct archive_string as;
	int r;

	if (value_length > 128) {
		__archive_read_consume(a, value_length);
		*ps = 0;
		*pn = 0;
		return (ARCHIVE_FATAL);
	}

	archive_string_init(&as);
	r = read_bytes_to_string(a, &as, value_length, unconsumed);
	if (r < ARCHIVE_OK) {
		archive_string_free(&as);
		return (r);
	}

	pax_time(as.s, archive_strlen(&as), ps, pn);
	archive_string_free(&as);
	if (*ps < 0 || *ps == INT64_MAX) {
		return (ARCHIVE_WARN);
	}
	return (ARCHIVE_OK);
}

static int
pax_attribute_read_number(struct archive_read *a, size_t value_length, int64_t *result) {
	struct archive_string as;
	size_t unconsumed = 0;
	int r;

	if (value_length > 64) {
		__archive_read_consume(a, value_length);
		*result = 0;
		return (ARCHIVE_FATAL);
	}

	archive_string_init(&as);
	r = read_bytes_to_string(a, &as, value_length, &unconsumed);
	tar_flush_unconsumed(a, &unconsumed);
	if (r < ARCHIVE_OK) {
		archive_string_free(&as);
		return (r);
	}

	*result = tar_atol10(as.s, archive_strlen(&as));
	archive_string_free(&as);
	if (*result < 0 || *result == INT64_MAX) {
		*result = INT64_MAX;
		return (ARCHIVE_WARN);
	}
	return (ARCHIVE_OK);
}

/*
 * Parse a single key=value attribute.
 * assumed to point into reasonably long-lived storage.
 *
 * POSIX reserves all-lowercase keywords.  Vendor-specific extensions
 * should always have keywords of the form "VENDOR.attribute" In
 * particular, it's quite feasible to support many different vendor
 * extensions here.  I'm using "LIBARCHIVE" for extensions unique to
 * this library.
 *
 * TODO: Investigate other vendor-specific extensions and see if
 * any of them look useful.
 */
static int
pax_attribute(struct archive_read *a, struct tar *tar, struct archive_entry *entry,
	      const char *key, size_t key_length, size_t value_length, size_t *unconsumed)
{
	int64_t t;
	long n;
	const char *p;
	ssize_t bytes_read;
	int err = ARCHIVE_OK;

#ifndef __FreeBSD__
	if (value == NULL)
		value = "";	/* Disable compiler warning; do not pass
				 * NULL pointer to strlen().  */
#endif
	switch (key[0]) {
	case 'G':
		/* GNU.* extensions */
		if (key_length > 4 && memcmp(key, "GNU.", 4) == 0) {
			key += 4;
			key_length -= 4;

			/* GNU.sparse marks the existence of GNU sparse information */
			if (key_length == 6 && memcmp(key, "sparse", 6) == 0) {
				tar->sparse_gnu_attributes_seen = 1;
		/* GNU "0.0" sparse pax format. */
		if (strcmp(key, "GNU.sparse.numblocks") == 0) {
			tar->sparse_offset = -1;
			tar->sparse_numbytes = -1;
			tar->sparse_gnu_major = 0;
			tar->sparse_gnu_minor = 0;
		}
		if (strcmp(key, "GNU.sparse.offset") == 0) {
			tar->sparse_offset = tar_atol10(value, strlen(value));
			if (tar->sparse_numbytes != -1) {
				if (gnu_add_sparse_entry(a, tar,
				    tar->sparse_offset, tar->sparse_numbytes)
				    != ARCHIVE_OK)
					return (ARCHIVE_FATAL);
				tar->sparse_offset = -1;
				tar->sparse_numbytes = -1;
			}
		}
		if (strcmp(key, "GNU.sparse.numbytes") == 0) {
			tar->sparse_numbytes = tar_atol10(value, strlen(value));
			if (tar->sparse_offset != -1) {
				if (gnu_add_sparse_entry(a, tar,
				    tar->sparse_offset, tar->sparse_numbytes)
				    != ARCHIVE_OK)
					return (ARCHIVE_FATAL);
				tar->sparse_offset = -1;
				tar->sparse_numbytes = -1;
			}
		}
		if (strcmp(key, "GNU.sparse.size") == 0) {
			tar->realsize = tar_atol10(value, strlen(value));
			archive_entry_set_size(entry, tar->realsize);
			tar->realsize_override = 1;
		}

			/* GNU.sparse.* extensions */
			else if (key_length > 7 && memcmp(key, "sparse.", 7) == 0) {
				tar->sparse_gnu_attributes_seen = 1;
				key += 7;
				key_length -= 7;

				/* GNU "0.0" sparse pax format. */
				if (key_length == 9 && memcmp(key, "numblocks", 9) == 0) {
					/* GNU.sparse.numblocks */
					tar->sparse_offset = -1;
					tar->sparse_numbytes = -1;
					tar->sparse_gnu_major = 0;
					tar->sparse_gnu_minor = 0;
				}
				else if (key_length == 6 && memcmp(key, "offset", 6) == 0) {
					/* GNU.sparse.offset */
					if ((err = pax_attribute_read_number(a, value_length, &t)) == ARCHIVE_OK) {
						tar->sparse_offset = t;
						if (tar->sparse_numbytes != -1) {
							if (gnu_add_sparse_entry(a, tar,
									 tar->sparse_offset, tar->sparse_numbytes)
							    != ARCHIVE_OK)
								return (ARCHIVE_FATAL);
							tar->sparse_offset = -1;
							tar->sparse_numbytes = -1;
						}
					}
					return (err);
				}
				else if (key_length == 8 && memcmp(key, "numbytes", 8) == 0) {
					/* GNU.sparse.numbytes */
					if ((err = pax_attribute_read_number(a, value_length, &t)) == ARCHIVE_OK) {
						tar->sparse_numbytes = t;
						if (tar->sparse_offset != -1) {
							if (gnu_add_sparse_entry(a, tar,
									 tar->sparse_offset, tar->sparse_numbytes)
							    != ARCHIVE_OK)
								return (ARCHIVE_FATAL);
							tar->sparse_offset = -1;
							tar->sparse_numbytes = -1;
						}
					}
					return (err);
				}
				else if (key_length == 4 && memcmp(key, "size", 4) == 0) {
					/* GNU.sparse.size */
					if ((err = pax_attribute_read_number(a, value_length, &t)) == ARCHIVE_OK) {
						tar->realsize = t;
						archive_entry_set_size(entry, tar->realsize);
						tar->realsize_override = 1;
					}
					return (err);
				}

				/* GNU "0.1" sparse pax format. */
				else if (key_length == 3 && memcmp(key, "map", 3) == 0) {
					/* GNU.sparse.map */
					tar->sparse_gnu_major = 0;
					tar->sparse_gnu_minor = 1;
					if (value_length > sparse_map_limit) {
						archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
								  "Unreasonably large sparse map: %d > %d",
								  (int)value_length, (int)sparse_map_limit);
						err = ARCHIVE_FAILED;
					} else {
						p = __archive_read_ahead(a, value_length, &bytes_read);
						if (p == NULL) {
							archive_set_error(&a->archive, EINVAL,
									  "Truncated archive"
									  " detected while reading GNU sparse data");
							return (ARCHIVE_FATAL);
						}
						if (gnu_sparse_01_parse(a, tar, p, value_length) != ARCHIVE_OK) {
							err = ARCHIVE_WARN;
						}
					}
					__archive_read_consume(a, value_length);
					return (err);
				}

				/* GNU "1.0" sparse pax format */
				else if (key_length == 5 && memcmp(key, "major", 5) == 0) {
					/* GNU.sparse.major */
					if ((err = pax_attribute_read_number(a, value_length, &t)) == ARCHIVE_OK
					    && t >= 0
					    && t <= 10) {
						tar->sparse_gnu_major = (int)t;
					}
					return (err);
				}
				else if (key_length == 5 && memcmp(key, "minor", 5) == 0) {
					/* GNU.sparse.minor */
					if ((err = pax_attribute_read_number(a, value_length, &t)) == ARCHIVE_OK
					    && t >= 0
					    && t <= 10) {
						tar->sparse_gnu_minor = (int)t;
					}
					return (err);
				}
				else if (key_length == 4 && memcmp(key, "name", 4) == 0) {
					/* GNU.sparse.name */
					/*
					 * The real filename; when storing sparse
					 * files, GNU tar puts a synthesized name into
					 * the regular 'path' attribute in an attempt
					 * to limit confusion. ;-)
					 */
					if (value_length > pathname_limit) {
						*unconsumed += value_length;
						err = ARCHIVE_WARN;
					} else {
						err = read_bytes_to_string(a, &(tar->entry_pathname_override),
									   value_length, unconsumed);
					}
					return (err);
				}
				else if (key_length == 8 && memcmp(key, "realsize", 8) == 0) {
					/* GNU.sparse.realsize */
					if ((err = pax_attribute_read_number(a, value_length, &t)) == ARCHIVE_OK) {
						tar->realsize = t;
						archive_entry_set_size(entry, tar->realsize);
						tar->realsize_override = 1;
					}
					return (err);
				}
			}
		}
		break;
	case 'L':
		/* LIBARCHIVE extensions */
		if (key_length > 11 && memcmp(key, "LIBARCHIVE.", 11) == 0) {
			key_length -= 11;
			key += 11;

			/* TODO: Handle arbitrary extended attributes... */
			/*
			  if (strcmp(key, "LIBARCHIVE.xxxxxxx") == 0)
				  archive_entry_set_xxxxxx(entry, value);
			*/
			if (key_length == 12 && memcmp(key, "creationtime", 12) == 0) {
				/* LIBARCHIVE.creationtime */
				if ((err = pax_attribute_read_time(a, value_length, &t, &n, unconsumed)) == ARCHIVE_OK) {
					archive_entry_set_birthtime(entry, t, n);
				}
				return (err);
			}
			else if (key_length == 11 && memcmp(key, "symlinktype", 11) == 0) {
				/* LIBARCHIVE.symlinktype */
				if (value_length < 16) {
					p = __archive_read_ahead(a, value_length, &bytes_read);
					if (p == NULL) {
						archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
								  "Truncated tar archive "
								  "detected while reading `symlinktype` attribute");
						return (ARCHIVE_FATAL);
					}
					if (value_length == 4 && memcmp(p, "file", 4) == 0) {
						archive_entry_set_symlink_type(entry,
									       AE_SYMLINK_TYPE_FILE);
					} else if (value_length == 3 && memcmp(p, "dir", 3) == 0) {
							archive_entry_set_symlink_type(entry,
										       AE_SYMLINK_TYPE_DIRECTORY);
					} else {
						archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
								  "Unrecognized symlink type");
						err = ARCHIVE_WARN;
					}
				} else {
					archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
							  "symlink type is very long"
							  "(longest recognized value is 4 bytes, this is %d)",
							  (int)value_length);
					err = ARCHIVE_WARN;
				}
				__archive_read_consume(a, value_length);
				return (err);
			}
			else if (key_length > 6 && memcmp(key, "xattr.", 6) == 0) {
				key_length -= 6;
				key += 6;
				if (value_length > xattr_limit) {
					err = ARCHIVE_WARN;
				} else {
					p = __archive_read_ahead(a, value_length, &bytes_read);
					if (p == NULL) {
						archive_set_error(&a->archive, EINVAL,
								  "Truncated archive"
								  " detected while reading xattr information");
						return (ARCHIVE_FATAL);
					}
					if (pax_attribute_LIBARCHIVE_xattr(entry, key, key_length, p, value_length)) {
						/* TODO: Unable to parse xattr */
						err = ARCHIVE_WARN;
					}
				}
				__archive_read_consume(a, value_length);
				return (err);
			}
		}
		if (memcmp(key, "LIBARCHIVE.xattr.", 17) == 0)
			pax_attribute_xattr(entry, key, value);
		break;
	case 'R':
		/* GNU tar uses RHT.security header to store SELinux xattrs
		 * SCHILY.xattr.security.selinux == RHT.security.selinux */
		if (key_length == 20 && memcmp(key, "RHT.security.selinux", 20) == 0) {
			if (value_length > xattr_limit) {
				archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
						  "Ignoring unreasonably large security.selinux attribute:"
						  " %d > %d",
						  (int)value_length, (int)xattr_limit);
				/* TODO: Should this be FAILED instead? */
				err = ARCHIVE_WARN;
			} else {
				p = __archive_read_ahead(a, value_length, &bytes_read);
				if (p == NULL) {
					archive_set_error(&a->archive, EINVAL,
							  "Truncated archive"
							  " detected while reading selinux data");
					return (ARCHIVE_FATAL);
				}
				if (pax_attribute_RHT_security_selinux(entry, p, value_length)) {
					/* TODO: Unable to parse xattr */
					err = ARCHIVE_WARN;
				}
			}
			__archive_read_consume(a, value_length);
			return (err);
		}
		break;
	case 'S':
		/* SCHILY.* extensions used by "star" archiver */
		if (key_length > 7 && memcmp(key, "SCHILY.", 7) == 0) {
			key_length -= 7;
			key += 7;

			if (key_length == 10 && memcmp(key, "acl.access", 10) == 0) {
				err = pax_attribute_SCHILY_acl(a, tar, entry, value_length,
						      ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
				// TODO: Mark mode as set
				return (err);
			}
			else if (key_length == 11 && memcmp(key, "acl.default", 11) == 0) {
				err = pax_attribute_SCHILY_acl(a, tar, entry, value_length,
						      ARCHIVE_ENTRY_ACL_TYPE_DEFAULT);
				return (err);
			}
			else if (key_length == 7 && memcmp(key, "acl.ace", 7) == 0) {
				err = pax_attribute_SCHILY_acl(a, tar, entry, value_length,
						      ARCHIVE_ENTRY_ACL_TYPE_NFS4);
				// TODO: Mark mode as set
				return (err);
			}
			else if (key_length == 8 && memcmp(key, "devmajor", 8) == 0) {
				if ((err = pax_attribute_read_number(a, value_length, &t)) == ARCHIVE_OK) {
					archive_entry_set_rdevmajor(entry, (dev_t)t);
				}
				return (err);
			}
			else if (key_length == 8 && memcmp(key, "devminor", 8) == 0) {
				if ((err = pax_attribute_read_number(a, value_length, &t)) == ARCHIVE_OK) {
					archive_entry_set_rdevminor(entry, (dev_t)t);
				}
				return (err);
			}
			else if (key_length == 6 && memcmp(key, "fflags", 6) == 0) {
				if (value_length < fflags_limit) {
					p = __archive_read_ahead(a, value_length, &bytes_read);
					if (p == NULL) {
						/* Truncated archive */
						archive_set_error(&a->archive, EINVAL,
								  "Truncated archive"
								  " detected while reading SCHILY.fflags");
						return (ARCHIVE_FATAL);
					}
					archive_entry_copy_fflags_text_len(entry, p, value_length);
					err = ARCHIVE_OK;
				} else {
					/* Overlong fflags field */
					err = ARCHIVE_WARN;
				}
				__archive_read_consume(a, value_length);
				return (err);
			}
			else if (key_length == 3 && memcmp(key, "dev", 3) == 0) {
				if ((err = pax_attribute_read_number(a, value_length, &t)) == ARCHIVE_OK) {
					archive_entry_set_dev(entry, (dev_t)t);
				}
				return (err);
			}
			else if (key_length == 3 && memcmp(key, "ino", 3) == 0) {
				if ((err = pax_attribute_read_number(a, value_length, &t)) == ARCHIVE_OK) {
					archive_entry_set_ino(entry, t);
				}
				return (err);
			}
			else if (key_length == 5 && memcmp(key, "nlink", 5) == 0) {
				if ((err = pax_attribute_read_number(a, value_length, &t)) == ARCHIVE_OK) {
					archive_entry_set_nlink(entry, (unsigned int)t);
				}
				return (err);
			}
			else if (key_length == 8 && memcmp(key, "realsize", 8) == 0) {
				if ((err = pax_attribute_read_number(a, value_length, &t)) == ARCHIVE_OK) {
					tar->realsize = t;
					tar->realsize_override = 1;
					archive_entry_set_size(entry, tar->realsize);
				}
				return (err);
			}
			else if (key_length > 6 && memcmp(key, "xattr.", 6) == 0) {
				key_length -= 6;
				key += 6;
				if (value_length < xattr_limit) {
					p = __archive_read_ahead(a, value_length, &bytes_read);
					if (p == NULL) {
						archive_set_error(&a->archive, EINVAL,
								  "Truncated archive"
								  " detected while reading SCHILY.xattr");
						return (ARCHIVE_FATAL);
					}
					if (pax_attribute_SCHILY_xattr(entry, key, key_length, p, value_length)) {
						/* TODO: Unable to parse xattr */
						err = ARCHIVE_WARN;
					}
				} else {
					archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
							  "Unreasonably large xattr: %d > %d",
							  (int)value_length, (int)xattr_limit);
					err = ARCHIVE_WARN;
				}
				__archive_read_consume(a, value_length);
				return (err);
			}
		}
		/* SUN.* extensions from Solaris tar */
		if (key_length > 4 && memcmp(key, "SUN.", 4) == 0) {
			key_length -= 4;
			key += 4;

			if (key_length == 9 && memcmp(key, "holesdata", 9) == 0) {
				/* SUN.holesdata */
				if (value_length < sparse_map_limit) {
					p = __archive_read_ahead(a, value_length, &bytes_read);
					if (p == NULL) {
						archive_set_error(&a->archive, EINVAL,
								  "Truncated archive"
								  " detected while reading SUN.holesdata");
						return (ARCHIVE_FATAL);
					}
					err = pax_attribute_SUN_holesdata(a, tar, entry, p, value_length);
					if (err < ARCHIVE_OK) {
						archive_set_error(&a->archive,
								  ARCHIVE_ERRNO_MISC,
								  "Parse error: SUN.holesdata");
					}
				} else {
					archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
							  "Unreasonably large sparse map: %d > %d",
							  (int)value_length, (int)sparse_map_limit);
					err = ARCHIVE_FAILED;
				}
				__archive_read_consume(a, value_length);
				return (err);
			}
		}
		break;
	case 'a':
		if (key_length == 5 && memcmp(key, "atime", 5) == 0) {
			if ((err = pax_attribute_read_time(a, value_length, &t, &n, unconsumed)) == ARCHIVE_OK) {
				archive_entry_set_atime(entry, t, n);
			}
			return (err);
		}
		break;
	case 'c':
		if (key_length == 5 && memcmp(key, "ctime", 5) == 0) {
			if ((err = pax_attribute_read_time(a, value_length, &t, &n, unconsumed)) == ARCHIVE_OK) {
				archive_entry_set_ctime(entry, t, n);
			}
			return (err);
		} else if (key_length == 7 && memcmp(key, "charset", 7) == 0) {
			/* TODO: Publish charset information in entry. */
		} else if (key_length == 7 && memcmp(key, "comment", 7) == 0) {
			/* TODO: Publish comment in entry. */
		}
		break;
	case 'g':
		if (key_length == 3 && memcmp(key, "gid", 3) == 0) {
			if ((err = pax_attribute_read_number(a, value_length, &t)) == ARCHIVE_OK) {
				archive_entry_set_gid(entry, t);
			}
			return (err);
		} else if (key_length == 5 && memcmp(key, "gname", 5) == 0) {
			if (value_length > guname_limit) {
				*unconsumed += value_length;
				err = ARCHIVE_WARN;
			} else {
				err = read_bytes_to_string(a, &(tar->entry_gname), value_length, unconsumed);
			}
			return (err);
		}
		break;
	case 'h':
		if (key_length == 10 && memcmp(key, "hdrcharset", 10) == 0) {
			if (value_length < 64) {
				p = __archive_read_ahead(a, value_length, &bytes_read);
				if (p == NULL) {
					archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
							  "Truncated tar archive "
							  "detected while reading hdrcharset attribute");
					return (ARCHIVE_FATAL);
				}
				if (value_length == 6
				    && memcmp(p, "BINARY", 6) == 0) {
					/* Binary  mode. */
					tar->pax_hdrcharset_utf8 = 0;
					err = ARCHIVE_OK;
				} else if (value_length == 23
					   && memcmp(p, "ISO-IR 10646 2000 UTF-8", 23) == 0) {
					tar->pax_hdrcharset_utf8 = 1;
					err = ARCHIVE_OK;
				} else {
					/* TODO: Unrecognized character set */
					err  = ARCHIVE_WARN;
				}
			} else {
				archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
						  "hdrcharset attribute is unreasonably large (%d bytes)",
						  (int)value_length);
				err = ARCHIVE_WARN;
			}
			__archive_read_consume(a, value_length);
			return (err);
		}
		break;
	case 'l':
		/* pax interchange doesn't distinguish hardlink vs. symlink. */
		if (key_length == 8 && memcmp(key, "linkpath", 8) == 0) {
			if (value_length > pathname_limit) {
				*unconsumed += value_length;
				err = ARCHIVE_WARN;
			} else {
				err = read_bytes_to_string(a, &tar->entry_linkpath, value_length, unconsumed);
			}
			return (err);
		}
		break;
	case 'm':
		if (key_length == 5 && memcmp(key, "mtime", 5) == 0) {
			if ((err = pax_attribute_read_time(a, value_length, &t, &n, unconsumed)) == ARCHIVE_OK) {
				archive_entry_set_mtime(entry, t, n);
			}
			return (err);
		}
		break;
	case 'p':
		if (key_length == 4 && memcmp(key, "path", 4) == 0) {
			if (value_length > pathname_limit) {
				*unconsumed += value_length;
				err = ARCHIVE_WARN;
			} else {
				err = read_bytes_to_string(a, &(tar->entry_pathname), value_length, unconsumed);
			}
			return (err);
		}
		break;
	case 'r':

	case 's':
		/* POSIX has reserved 'security.*' */
		/* Someday: if (strcmp(key, "security.acl") == 0) { ... } */
		if (key_length == 4 && memcmp(key, "size", 4) == 0) {
			/* "size" is the size of the data in the entry. */
			if ((err = pax_attribute_read_number(a, value_length, &t)) == ARCHIVE_OK) {
				tar->entry_bytes_remaining = t;
				/*
				 * The "size" pax header keyword always overrides the
				 * "size" field in the tar header.
				 * GNU.sparse.realsize, GNU.sparse.size and
				 * SCHILY.realsize override this value.
				 */
				if (!tar->realsize_override) {
					archive_entry_set_size(entry,
							       tar->entry_bytes_remaining);
					tar->realsize
						= tar->entry_bytes_remaining;
				}
			}
			else if (t == INT64_MAX) {
				/* Note: pax_attr_read_number returns INT64_MAX on overflow or < 0 */
				tar->entry_bytes_remaining = 0;
				archive_set_error(&a->archive,
				    ARCHIVE_ERRNO_MISC,
				    "Tar size attribute overflow");
				return (ARCHIVE_FATAL);
			}
			return (err);
			 * The "size" pax header keyword always overrides the
			 * "size" field in the tar header.
			 * GNU.sparse.realsize, GNU.sparse.size and
			 * SCHILY.realsize override this value.
			 */
			if (!tar->realsize_override) {
				archive_entry_set_size(entry,
				    tar->entry_bytes_remaining);
				tar->realsize
				    = tar->entry_bytes_remaining;
			}
		}
		break;
	case 'u':
		if (key_length == 3 && memcmp(key, "uid", 3) == 0) {
			if ((err = pax_attribute_read_number(a, value_length, &t)) == ARCHIVE_OK) {
				archive_entry_set_uid(entry, t);
			}
			return (err);
		} else if (key_length == 5 && memcmp(key, "uname", 5) == 0) {
			if (value_length > guname_limit) {
				*unconsumed += value_length;
				err = ARCHIVE_WARN;
			} else {
				err = read_bytes_to_string(a, &(tar->entry_uname), value_length, unconsumed);
			}
			return (err);
		}
		break;
	}

	/* Unrecognized key, just skip the entire value. */
	__archive_read_consume(a, value_length);
	return (err);
}


 * parse a decimal time value, which may include a fractional portion
 */
static void
pax_time(const char *p, size_t length, int64_t *ps, long *pn)
{
	char digit;
	int64_t	s;

	limit = INT64_MAX / 10;
	last_digit_limit = INT64_MAX % 10;

	if (length <= 0) {
		*ps = 0;
		return;
	}
	s = 0;
	sign = 1;
	if (*p == '-') {
		sign = -1;
		p++;
		length--;
	}
	while (length > 0 && *p >= '0' && *p <= '9') {
		digit = *p - '0';
		if (s > limit ||
		    (s == limit && digit > last_digit_limit)) {

		}
		s = (s * 10) + digit;
		++p;
		--length;
	}

	*ps = s * sign;

	/* Calculate nanoseconds. */
	*pn = 0;

	if (length <= 0 || *p != '.')
		return;

	l = 100000000UL;
	do {
		++p;
		--length;
		if (length > 0 && *p >= '0' && *p <= '9')
			*pn += (*p - '0') * l;
		else
			break;


	/* Copy filename over (to ensure null termination). */
	header = (const struct archive_entry_header_gnutar *)h;
	const char *existing_pathname = archive_entry_pathname(entry);
	if (existing_pathname == NULL || existing_pathname[0] == '\0') {
		if (archive_entry_copy_pathname_l(entry,
		    header->name, sizeof(header->name), tar->sconv) != 0) {
			err = set_conversion_failed_error(a, tar->sconv, "Pathname");
			if (err == ARCHIVE_FATAL)
				return (err);
		}
	}

	/* Fields common to ustar and GNU */
	/* XXX Can the following be factored out since it's common
	 * to ustar and gnu tar?  Is it okay to move it down into
	 * header_common, perhaps?  */
	const char *existing_uname = archive_entry_uname(entry);
	if (existing_uname == NULL || existing_uname[0] == '\0') {
		if (archive_entry_copy_uname_l(entry,
		    header->uname, sizeof(header->uname), tar->sconv) != 0) {
			err = set_conversion_failed_error(a, tar->sconv, "Uname");
			if (err == ARCHIVE_FATAL)
				return (err);
		}
	}

	const char *existing_gname = archive_entry_gname(entry);
	if (existing_gname == NULL || existing_gname[0] == '\0') {
		if (archive_entry_copy_gname_l(entry,
		    header->gname, sizeof(header->gname), tar->sconv) != 0) {
			err = set_conversion_failed_error(a, tar->sconv, "Gname");
			if (err == ARCHIVE_FATAL)
				return (err);
		}
	}

	/* Parse out device numbers only for char and block specials */
	if (header->typeflag[0] == '3' || header->typeflag[0] == '4') {
		if (!archive_entry_rdev_is_set(entry)) {
			archive_entry_set_rdevmajor(entry, (dev_t)
			    tar_atol(header->rdevmajor, sizeof(header->rdevmajor)));
			archive_entry_set_rdevminor(entry, (dev_t)
			    tar_atol(header->rdevminor, sizeof(header->rdevminor)));
		}
	} else {
		archive_entry_set_rdev(entry, 0);
	}

	tar->entry_padding = 0x1ff & (-tar->entry_bytes_remaining);

	/* Grab GNU-specific fields. */
	if (!archive_entry_atime_is_set(entry)) {
		t = tar_atol(header->atime, sizeof(header->atime));
		if (t > 0)
			archive_entry_set_atime(entry, t, 0);
	}
	if (!archive_entry_ctime_is_set(entry)) {
		t = tar_atol(header->ctime, sizeof(header->ctime));
		if (t > 0)
			archive_entry_set_ctime(entry, t, 0);
	}

	if (header->realsize[0] != 0) {
		tar->realsize

{
	struct sparse_block *p;

	p = calloc(1, sizeof(*p));
	if (p == NULL) {
		archive_set_error(&a->archive, ENOMEM, "Out of memory");
		return (ARCHIVE_FATAL);

	do {
		tar_flush_unconsumed(a, unconsumed);
		data = __archive_read_ahead(a, 512, &bytes_read);
		if (data == NULL) {
			return (ARCHIVE_FATAL);
		if (bytes_read < 512) {
			archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
			    "Truncated tar archive "
			    "detected while reading sparse file data");

 * importantly, the sparse data was lost when extracted by archivers
 * that didn't recognize this extension.
 */

static int
gnu_sparse_01_parse(struct archive_read *a, struct tar *tar, const char *p, size_t length)
{
	const char *e;
	int64_t offset = -1, size = -1;

	for (;;) {
		e = p;
		while (length > 0 && *e != ',') {
			if (*e < '0' || *e > '9')
				return (ARCHIVE_WARN);
			e++;
			length--;
		}
		if (offset < 0) {
			offset = tar_atol10(p, e - p);

				return (ARCHIVE_FATAL);
			offset = -1;
		}
		if (length == 0)
			return (ARCHIVE_OK);
		p = e + 1;
		length--;
	}
}


 * consist of both data and hole.
 */
static int
pax_attribute_SUN_holesdata(struct archive_read *a, struct tar *tar,
	struct archive_entry *entry, const char *p, size_t length)
{
	const char *e;
	int64_t start, end;

	(void)entry; /* UNUSED */

	end = 0;
	if (length <= 0)
		return (ARCHIVE_WARN);
	if (*p == ' ') {
		p++;
		length--;
	} else {
		return (ARCHIVE_WARN);
	}
	for (;;) {
		e = p;
		while (length > 0 && *e != ' ') {
			if (*e < '0' || *e > '9')
				return (ARCHIVE_WARN);
			e++;
			length--;
		}
		start = end;
		end = tar_atol10(p, e - p);

				return (ARCHIVE_FATAL);
			tar->sparse_last->hole = hole;
		}
		if (length == 0 || *e == '\n') {
			if (length == 0 && *e == '\n') {
				return (ARCHIVE_OK);
			} else {
				return (ARCHIVE_WARN);
			}
		}
		p = e + 1;
		length--;
		hole = hole == 0;
	}
}

	tar_flush_unconsumed(a, unconsumed);

	t = __archive_read_ahead(a, 1, &bytes_read);
	if (bytes_read <= 0 || t == NULL)
		return (ARCHIVE_FATAL);
	s = t;  /* Start of line? */
	p = memchr(t, '\n', bytes_read);

		}
		/* Read some more. */
		t = __archive_read_ahead(a, 1, &bytes_read);
		if (bytes_read <= 0 || t == NULL)
			return (ARCHIVE_FATAL);
		s = t;  /* Start of line? */
		p = memchr(t, '\n', bytes_read);


	/* Allocate enough space to hold the entire output. */
	/* Note that we may not use all of this... */
	out = malloc(len - len / 4 + 1);
	if (out == NULL) {
		*out_len = 0;
		return (NULL);

}

static char *
url_decode(const char *in, size_t length)
{
	char *out, *d;
	const char *s;

	out = malloc(length + 1);
	if (out == NULL)
		return (NULL);
	for (s = in, d = out; length > 0 && *s != '\0'; ) {
		if (s[0] == '%' && length > 2) {
			/* Try to convert % escape */
			int digit1 = tohex(s[1]);
			int digit2 = tohex(s[2]);
			if (digit1 >= 0 && digit2 >= 0) {
				/* Looks good, consume three chars */
				s += 3;
				length -= 3;
				/* Convert output */
				*d++ = ((digit1 << 4) | digit2);
				continue;

			/* Else fall through and treat '%' as normal char */
		}
		*d++ = *s++;
		--length;
	}
	*d = '\0';
	return (out);




static int	xml_start(struct archive_read *,
    const char *, struct xmlattr_list *);
static void	xml_end(void *, const char *);
static void	xml_data(void *, const char *, size_t);
static int	xml_parse_file_flags(struct xar *, const char *);
static int	xml_parse_file_ext2(struct xar *, const char *);
#if defined(HAVE_LIBXML_XMLREADER_H)

	archive_check_magic(_a, ARCHIVE_READ_MAGIC,
	    ARCHIVE_STATE_NEW, "archive_read_support_format_xar");

	xar = calloc(1, sizeof(*xar));
	if (xar == NULL) {
		archive_set_error(&a->archive, ENOMEM,
		    "Can't allocate xar data");

			return (ARCHIVE_FATAL);
		}
		new_pending_files = (struct xar_file **)
		    calloc(new_size, sizeof(new_pending_files[0]));
		if (new_pending_files == NULL) {
			archive_set_error(&a->archive,
			    ENOMEM, "Out of memory");

	switch (xar->rd_encoding) {
	case GZIP:
		xar->stream.next_in = (Bytef *)(uintptr_t)b;
		xar->stream.avail_in = (uInt)avail_in;
		xar->stream.next_out = (unsigned char *)outbuff;
		xar->stream.avail_out = (uInt)avail_out;
		r = inflate(&(xar->stream), 0);
		switch (r) {
		case Z_OK: /* Decompressor made some progress.*/

#if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
	case BZIP2:
		xar->bzstream.next_in = (char *)(uintptr_t)b;
		xar->bzstream.avail_in = (unsigned int)avail_in;
		xar->bzstream.next_out = (char *)outbuff;
		xar->bzstream.avail_out = (unsigned int)avail_out;
		r = BZ2_bzDecompress(&(xar->bzstream));
		switch (r) {
		case BZ_STREAM_END: /* Found end of stream. */

}

static void
xml_data(void *userData, const char *s, size_t len)
{
	struct archive_read *a;
	struct xar *xar;


	switch (xar->xmlsts) {
	case FILE_NAME:
		if (xar->file->has & HAS_PATHNAME)
			break;

		if (xar->file->parent != NULL) {
			archive_string_concat(&(xar->file->pathname),
			    &(xar->file->parent->pathname));

			if (r == ARCHIVE_OK)
				r = xml_start(a, name, &list);
			xmlattr_cleanup(&list);
			if (r != ARCHIVE_OK) {
				xmlFreeTextReader(reader);
				xmlCleanupParser();
				return (r);
			}
			if (empty)
				xml_end(a, name);
			break;

{
	struct expat_userData *ud = (struct expat_userData *)userData;

	xml_data(ud->archive, s, (size_t)len);
}

static int


		d = NULL;
		r = rd_contents(a, &d, &outbytes, &used, xar->toc_remaining);
		if (r != ARCHIVE_OK) {
			XML_ParserFree(parser);
			return (r);
		}
		xar->toc_remaining -= used;
		xar->offset += used;
		xar->toc_total += outbytes;
		PRINT_TOC(d, outbytes);

		xr = XML_Parse(parser, d, (int)outbytes, xar->toc_remaining == 0);
		__archive_read_consume(a, used);
		if (xr == XML_STATUS_ERROR) {
			XML_ParserFree(parser);




	free(zip->uncompressed_buffer);

	zip->uncompressed_buffer_size = 256 * 1024;
	zip->uncompressed_buffer = malloc(zip->uncompressed_buffer_size);
	    (uint8_t*) malloc(zip->uncompressed_buffer_size);
	if (zip->uncompressed_buffer == NULL) {
		archive_set_error(&a->archive, ENOMEM,
		    "No memory for xz decompression");


	if(!zip->uncompressed_buffer) {
		zip->uncompressed_buffer_size = 256 * 1024;
		zip->uncompressed_buffer = malloc(zip->uncompressed_buffer_size);
			(uint8_t*) malloc(zip->uncompressed_buffer_size);

		if (zip->uncompressed_buffer == NULL) {
			archive_set_error(&a->archive, ENOMEM,

		return (ARCHIVE_FATAL);
	}

	in_bytes = (ssize_t)zipmin(zip->entry_bytes_remaining, bytes_avail);
	zip->zipx_lzma_stream.next_in = compressed_buf;
	zip->zipx_lzma_stream.avail_in = in_bytes;
	zip->zipx_lzma_stream.total_in = 0;

			break;
	}

	to_consume = (ssize_t)zip->zipx_lzma_stream.total_in;

	__archive_read_consume(a, to_consume);
	zip->entry_bytes_remaining -= to_consume;
	zip->entry_compressed_bytes_read += to_consume;
	zip->entry_uncompressed_bytes_read += zip->zipx_lzma_stream.total_out;

	*size = (size_t)zip->zipx_lzma_stream.total_out;
	*buff = zip->uncompressed_buffer;

	return (ARCHIVE_OK);

	}

	/* Set decompressor parameters. */
	in_bytes = (ssize_t)zipmin(zip->entry_bytes_remaining, bytes_avail);

	zip->zipx_lzma_stream.next_in = compressed_buf;
	zip->zipx_lzma_stream.avail_in = in_bytes;

		/* These lzma_alone streams lack end of stream marker, so let's
		 * make sure the unpacker won't try to unpack more than it's
		 * supposed to. */
		(size_t)zipmin((int64_t) zip->uncompressed_buffer_size,
		    zip->entry->uncompressed_size -
		    zip->entry_uncompressed_bytes_read);
	zip->zipx_lzma_stream.total_out = 0;

			return (ARCHIVE_FATAL);
	}

	to_consume = (ssize_t)zip->zipx_lzma_stream.total_in;

	/* Update pointers. */
	__archive_read_consume(a, to_consume);

	}

	/* Return values. */
	*size = (size_t)zip->zipx_lzma_stream.total_out;
	*buff = zip->uncompressed_buffer;

	/* If we're here, then we're good! */

	free(zip->uncompressed_buffer);

	zip->uncompressed_buffer_size = 256 * 1024;
	zip->uncompressed_buffer = malloc(zip->uncompressed_buffer_size);
	    (uint8_t*) malloc(zip->uncompressed_buffer_size);

	if(zip->uncompressed_buffer == NULL) {
		archive_set_error(&a->archive, ENOMEM,

	free(zip->uncompressed_buffer);

	zip->uncompressed_buffer_size = 256 * 1024;
	zip->uncompressed_buffer = malloc(zip->uncompressed_buffer_size);
	    (uint8_t*) malloc(zip->uncompressed_buffer_size);
	if (zip->uncompressed_buffer == NULL) {
		archive_set_error(&a->archive, ENOMEM,
		    "No memory for bzip2 decompression");

		return (ARCHIVE_FATAL);
	}

	in_bytes = (ssize_t)zipmin(zip->entry_bytes_remaining, bytes_avail);
	if(in_bytes < 1) {
		/* libbz2 doesn't complain when caller feeds avail_in == 0.
		 * It will actually return success in this case, which is

	zip->entry_uncompressed_bytes_read += total_out;

	/* Give libarchive its due. */
	*size = (size_t)total_out;
	*buff = zip->uncompressed_buffer;

	return ARCHIVE_OK;

	free(zip->uncompressed_buffer);

	zip->uncompressed_buffer_size = ZSTD_DStreamOutSize();
	zip->uncompressed_buffer = malloc(zip->uncompressed_buffer_size);
	    (uint8_t*) malloc(zip->uncompressed_buffer_size);
	if (zip->uncompressed_buffer == NULL) {
		archive_set_error(&a->archive, ENOMEM,
			"No memory for Zstd decompression");

		return (ARCHIVE_FATAL);
	}

	in_bytes = (ssize_t)zipmin(zip->entry_bytes_remaining, bytes_avail);
	if(in_bytes < 1) {
		/* zstd doesn't complain when caller feeds avail_in == 0.
		 * It will actually return success in this case, which is

	zip->entry_uncompressed_bytes_read += total_out;

	/* Give libarchive its due. */
	*size = (size_t)total_out;
	*buff = zip->uncompressed_buffer;

	return ARCHIVE_OK;

	if (zip->uncompressed_buffer == NULL) {
		zip->uncompressed_buffer_size = 256 * 1024;
		zip->uncompressed_buffer
		    = malloc(zip->uncompressed_buffer_size);
		if (zip->uncompressed_buffer == NULL) {
			archive_set_error(&a->archive, ENOMEM,
			    "No memory for ZIP decompression");

	archive_check_magic(_a, ARCHIVE_READ_MAGIC,
	    ARCHIVE_STATE_NEW, "archive_read_support_format_zip");

	zip = calloc(1, sizeof(*zip));
	if (zip == NULL) {
		archive_set_error(&a->archive, ENOMEM,
		    "Can't allocate zip data");

	if (archive_le16dec(p + 10) != archive_le16dec(p + 8))
		return 0;
	/* Central directory can't extend beyond start of EOCD record. */
	if ((int64_t)cd_offset + cd_size > current_offset)
		return 0;

	/* Save the central directory location for later use. */

	archive_check_magic(_a, ARCHIVE_READ_MAGIC,
	    ARCHIVE_STATE_NEW, "archive_read_support_format_zip_seekable");

	zip = calloc(1, sizeof(*zip));
	if (zip == NULL) {
		archive_set_error(&a->archive, ENOMEM,
		    "Can't allocate zip data");




	if (new_length < s)
		new_length = s;
	/* Now we can reallocate the buffer. */
	p = realloc(as->s, new_length);
	if (p == NULL) {
		/* On failure, wipe the string and return NULL. */
		archive_string_free(as);

	}

	*p = NULL;
#if defined(_WIN32) && !defined(__CYGWIN__)
	/*
	 * On Windows, first try converting from WCS because (1) there's no
	 * guarantee that the conversion to MBS will succeed, e.g. when using
	 * CP_ACP, and (2) that's more efficient than converting to MBS, just to
	 * convert back to WCS again before finally converting to UTF-8
	 */
	if ((aes->aes_set & AES_SET_WCS) != 0) {
		sc = archive_string_conversion_to_charset(a, "UTF-8", 1);
		if (sc == NULL)
			return (-1);/* Couldn't allocate memory for sc. */
		archive_string_empty(&(aes->aes_utf8));
		r = archive_string_append_from_wcs_in_codepage(&(aes->aes_utf8),
			aes->aes_wcs.s, aes->aes_wcs.length, sc);
		if (a == NULL)
			free_sconv_object(sc);
		if (r == 0) {
			aes->aes_set |= AES_SET_UTF8;
			*p = aes->aes_utf8.s;
			return (0);/* success. */
		} else
			return (-1);/* failure. */
	}
#endif
	/* Try converting WCS to MBS first if MBS does not exist yet. */
	if ((aes->aes_set & AES_SET_MBS) == 0) {
		const char *pm; /* unused */

	}

	*wp = NULL;
#if defined(_WIN32) && !defined(__CYGWIN__)
	/*
	 * On Windows, prefer converting from UTF-8 directly to WCS because:
	 * (1) there's no guarantee that the string can be represented in MBS (e.g.
	 * with CP_ACP), and (2) in order to convert from UTF-8 to MBS, we're going
	 * to need to convert from UTF-8 to WCS anyway and its wasteful to throw
	 * away that intermediate result
	 */
	if (aes->aes_set & AES_SET_UTF8) {
		struct archive_string_conv *sc;

		sc = archive_string_conversion_from_charset(a, "UTF-8", 1);
		if (sc != NULL) {
			archive_wstring_empty((&aes->aes_wcs));
			r = archive_wstring_append_from_mbs_in_codepage(&(aes->aes_wcs),
			    aes->aes_utf8.s, aes->aes_utf8.length, sc);
			if (a == NULL)
				free_sconv_object(sc);
			if (r == 0) {
				aes->aes_set |= AES_SET_WCS;
				*wp = aes->aes_wcs.s;
				return (0);
			}
		}
	}
#endif
	/* Try converting UTF8 to MBS first if MBS does not exist yet. */
	if ((aes->aes_set & AES_SET_MBS) == 0) {
		const char *p; /* unused */


	aes->aes_set = AES_SET_UTF8;	/* Only UTF8 is set now. */

	/* Try converting UTF-8 to MBS, return false on failure. */
	sc = archive_string_conversion_from_charset(a, "UTF-8", 1);
	if (sc == NULL)
		return (-1);/* Couldn't allocate memory for sc. */
	r = archive_strcpy_l(&(aes->aes_mbs), utf8, sc);

#if defined(_WIN32) && !defined(__CYGWIN__)
	/* On Windows, there's no good way to convert from UTF8 -> MBS directly, so
	 * prefer to first convert to WCS as (1) it's wasteful to throw away the
	 * intermediate result, and (2) WCS will still be set even if we fail to
	 * convert to MBS (e.g. with ACP that can't represent the characters) */
	r = archive_wstring_append_from_mbs_in_codepage(&(aes->aes_wcs),
		aes->aes_utf8.s, aes->aes_utf8.length, sc);

	if (a == NULL)
		free_sconv_object(sc);
	if (r != 0)
		return (-1); /* This will guarantee we can't convert to MBS */
	aes->aes_set = AES_SET_UTF8 | AES_SET_WCS; /* Both UTF8 and WCS set. */

	/* Try converting WCS to MBS, return false on failure. */
	if (archive_string_append_from_wcs(&(aes->aes_mbs), aes->aes_wcs.s,
	    aes->aes_wcs.length))
		return (-1);
#else
	/* Try converting UTF-8 to MBS, return false on failure. */
	r = archive_strcpy_l(&(aes->aes_mbs), utf8, sc);

	if (a == NULL)
		free_sconv_object(sc);

	if (archive_wstring_append_from_mbs(&(aes->aes_wcs), aes->aes_mbs.s,
	    aes->aes_mbs.length))
		return (-1);
#endif

	/* All conversions succeeded. */
	aes->aes_set = AES_SET_UTF8 | AES_SET_WCS | AES_SET_MBS;

	return (0);
}




			if (archive_wstring_append_from_mbs(&temp_name, tmpdir,
			    strlen(tmpdir)) < 0)
				goto exit_tmpfile;
			if (temp_name.length == 0 ||
			    temp_name.s[temp_name.length-1] != L'/')
				archive_wstrappend_wchar(&temp_name, L'/');
		}


                tmp = "/tmp";
#endif
	archive_strcpy(temppath, tmp);
	if (temppath->length == 0 || temppath->s[temppath->length-1] != '/')
		archive_strappend_char(temppath, '/');
	return (ARCHIVE_OK);
}

			goto exit_tmpfile;
	} else {
		archive_strcpy(&temp_name, tmpdir);
		if (temp_name.length == 0 ||
		    temp_name.s[temp_name.length-1] != '/')
			archive_strappend_char(&temp_name, '/');
	}
#ifdef O_TMPFILE

				goto exit_tmpfile;
		} else
			archive_strcpy(&temp_name, tmpdir);
		if (temp_name.length > 0 && temp_name.s[temp_name.length-1] == '/') {
			temp_name.s[temp_name.length-1] = '\0';
			temp_name.length --;
		}

		if (strcmp(strings[i], pivot) < 0)
		{
			lesser_count++;
			tmp = realloc(lesser, lesser_count * sizeof(*tmp));
				lesser_count * sizeof(char *));
			if (!tmp) {
				free(greater);
				free(lesser);

		else
		{
			greater_count++;
			tmp = realloc(greater, greater_count * sizeof(*tmp));
				greater_count * sizeof(char *));
			if (!tmp) {
				free(greater);
				free(lesser);

Lines 98-104 archive_write_new(void) Link Here

(-)b/contrib/libarchive/libarchive/archive_write.c (-5 / +14 lines)
98	struct archive_write *a;	98	struct archive_write *a;
99	unsigned char *nulls;	99	unsigned char *nulls;
100		100
101	a = (struct archive_write )calloc(1, sizeof(a));	101	a = calloc(1, sizeof(*a));
102	if (a == NULL)	102	if (a == NULL)
103	return (NULL);	103	return (NULL);
104	a->archive.magic = ARCHIVE_WRITE_MAGIC;	104	a->archive.magic = ARCHIVE_WRITE_MAGIC;
Lines 114-120 archive_write_new(void) Link Here
114		114
115	/* Initialize a block of nulls for padding purposes. */	115	/* Initialize a block of nulls for padding purposes. */
116	a->null_length = 1024;	116	a->null_length = 1024;
117	nulls = (unsigned char *)calloc(a->null_length, sizeof(unsigned char));	117	nulls = calloc(a->null_length, sizeof(unsigned char));
118	if (nulls == NULL) {	118	if (nulls == NULL) {
119	free(a);	119	free(a);
120	return (NULL);	120	return (NULL);
Lines 132-143 archive_write_set_bytes_per_block(struct archive *_a, int bytes_per_block) Link Here
132	struct archive_write a = (struct archive_write )_a;	132	struct archive_write a = (struct archive_write )_a;
133	archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,	133	archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
134	ARCHIVE_STATE_NEW, "archive_write_set_bytes_per_block");	134	ARCHIVE_STATE_NEW, "archive_write_set_bytes_per_block");
		135
		136	if (bytes_per_block < 0) {
		137	// Do nothing if the bytes_per_block is negative
		138	return 0;
		139	}
135	a->bytes_per_block = bytes_per_block;	140	a->bytes_per_block = bytes_per_block;
136	return (ARCHIVE_OK);	141	return (ARCHIVE_OK);
137	}	142	}
138		143
139	/*	144	/*
140	* Get the current block size. -1 if it has never been set.	145	* Get the current block size.
141	*/	146	*/
142	int	147	int
143	archive_write_get_bytes_per_block(struct archive *_a)	148	archive_write_get_bytes_per_block(struct archive *_a)
Lines 145-150 archive_write_get_bytes_per_block(struct archive *_a) Link Here
145	struct archive_write a = (struct archive_write )_a;	150	struct archive_write a = (struct archive_write )_a;
146	archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,	151	archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
147	ARCHIVE_STATE_ANY, "archive_write_get_bytes_per_block");	152	ARCHIVE_STATE_ANY, "archive_write_get_bytes_per_block");
		153	if (a->bytes_per_block < 0) {
		154	// Don't return a negative value
		155	return 1;
		156	}
148	return (a->bytes_per_block);	157	return (a->bytes_per_block);
149	}	158	}
150		159
Lines 358-365 archive_write_client_open(struct archive_write_filter *f) Link Here
358	archive_write_get_bytes_in_last_block(f->archive);	367	archive_write_get_bytes_in_last_block(f->archive);
359	buffer_size = f->bytes_per_block;	368	buffer_size = f->bytes_per_block;
360		369
361	state = (struct archive_none )calloc(1, sizeof(state));	370	state = calloc(1, sizeof(*state));
362	buffer = (char *)malloc(buffer_size);	371	buffer = malloc(buffer_size);
363	if (state == NULL \|\| buffer == NULL) {	372	if (state == NULL \|\| buffer == NULL) {
364	free(state);	373	free(state);
365	free(buffer);	374	free(buffer);




	struct private_b64encode *state;

	archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
	    ARCHIVE_STATE_NEW, "archive_write_add_filter_b64encode");

	state = calloc(1, sizeof(*state));
	if (state == NULL) {
		archive_set_error(f->archive, ENOMEM,
		    "Can't allocate data for b64encode filter");

	size_t bs = 65536, bpb;

	if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
		/* Buffer size should be a multiple number of the bytes
		 * per block for performance. */
		bpb = archive_write_get_bytes_per_block(f->archive);
		if (bpb > bs)

Lines 168-174 archive_compressor_bzip2_open(struct archive_write_filter *f) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_add_filter_bzip2.c (-3 / +2 lines)
168	if (data->compressed == NULL) {	168	if (data->compressed == NULL) {
169	size_t bs = 65536, bpb;	169	size_t bs = 65536, bpb;
170	if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {	170	if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
171	/* Buffer size should be a multiple number of the of bytes	171	/* Buffer size should be a multiple number of the bytes
172	* per block for performance. */	172	* per block for performance. */
173	bpb = archive_write_get_bytes_per_block(f->archive);	173	bpb = archive_write_get_bytes_per_block(f->archive);
174	if (bpb > bs)	174	if (bpb > bs)
Lines 177-184 archive_compressor_bzip2_open(struct archive_write_filter *f) Link Here
177	bs -= bs % bpb;	177	bs -= bs % bpb;
178	}	178	}
179	data->compressed_buffer_size = bs;	179	data->compressed_buffer_size = bs;
180	data->compressed	180	data->compressed = malloc(data->compressed_buffer_size);
181	= (char *)malloc(data->compressed_buffer_size);
182	if (data->compressed == NULL) {	181	if (data->compressed == NULL) {
183	archive_set_error(f->archive, ENOMEM,	182	archive_set_error(f->archive, ENOMEM,
184	"Can't allocate data for compression buffer");	183	"Can't allocate data for compression buffer");

Lines 150-156 archive_compressor_compress_open(struct archive_write_filter *f) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_add_filter_compress.c (-2 / +2 lines)
150	f->code = ARCHIVE_FILTER_COMPRESS;	150	f->code = ARCHIVE_FILTER_COMPRESS;
151	f->name = "compress";	151	f->name = "compress";
152		152
153	state = (struct private_data )calloc(1, sizeof(state));	153	state = calloc(1, sizeof(*state));
154	if (state == NULL) {	154	if (state == NULL) {
155	archive_set_error(f->archive, ENOMEM,	155	archive_set_error(f->archive, ENOMEM,
156	"Can't allocate data for compression");	156	"Can't allocate data for compression");
Lines 158-164 archive_compressor_compress_open(struct archive_write_filter *f) Link Here
158	}	158	}
159		159
160	if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {	160	if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
161	/* Buffer size should be a multiple number of the of bytes	161	/* Buffer size should be a multiple number of the bytes
162	* per block for performance. */	162	* per block for performance. */
163	bpb = archive_write_get_bytes_per_block(f->archive);	163	bpb = archive_write_get_bytes_per_block(f->archive);
164	if (bpb > bs)	164	if (bpb > bs)

Lines 194-201 archive_compressor_gzip_open(struct archive_write_filter *f) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_add_filter_gzip.c (-2 / +1 lines)
194	bs -= bs % bpb;	194	bs -= bs % bpb;
195	}	195	}
196	data->compressed_buffer_size = bs;	196	data->compressed_buffer_size = bs;
197	data->compressed	197	data->compressed = malloc(data->compressed_buffer_size);
198	= (unsigned char *)malloc(data->compressed_buffer_size);
199	if (data->compressed == NULL) {	198	if (data->compressed == NULL) {
200	archive_set_error(f->archive, ENOMEM,	199	archive_set_error(f->archive, ENOMEM,
201	"Can't allocate data for compression buffer");	200	"Can't allocate data for compression buffer");

Lines 74-80 archive_write_add_filter_uuencode(struct archive *_a) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_add_filter_uuencode.c (-1 / +1 lines)
74	archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,	74	archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
75	ARCHIVE_STATE_NEW, "archive_write_add_filter_uu");	75	ARCHIVE_STATE_NEW, "archive_write_add_filter_uu");
76		76
77	state = (struct private_uuencode )calloc(1, sizeof(state));	77	state = calloc(1, sizeof(*state));
78	if (state == NULL) {	78	if (state == NULL) {
79	archive_set_error(f->archive, ENOMEM,	79	archive_set_error(f->archive, ENOMEM,
80	"Can't allocate data for uuencode filter");	80	"Can't allocate data for uuencode filter");

Lines 310-316 archive_compressor_xz_open(struct archive_write_filter *f) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_add_filter_xz.c (-3 / +2 lines)
310	if (data->compressed == NULL) {	310	if (data->compressed == NULL) {
311	size_t bs = 65536, bpb;	311	size_t bs = 65536, bpb;
312	if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {	312	if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
313	/* Buffer size should be a multiple number of the of bytes	313	/* Buffer size should be a multiple number of the bytes
314	* per block for performance. */	314	* per block for performance. */
315	bpb = archive_write_get_bytes_per_block(f->archive);	315	bpb = archive_write_get_bytes_per_block(f->archive);
316	if (bpb > bs)	316	if (bpb > bs)
Lines 319-326 archive_compressor_xz_open(struct archive_write_filter *f) Link Here
319	bs -= bs % bpb;	319	bs -= bs % bpb;
320	}	320	}
321	data->compressed_buffer_size = bs;	321	data->compressed_buffer_size = bs;
322	data->compressed	322	data->compressed = malloc(data->compressed_buffer_size);
323	= (unsigned char *)malloc(data->compressed_buffer_size);
324	if (data->compressed == NULL) {	323	if (data->compressed == NULL) {
325	archive_set_error(f->archive, ENOMEM,	324	archive_set_error(f->archive, ENOMEM,
326	"Can't allocate data for compression buffer");	325	"Can't allocate data for compression buffer");

Lines 372-379 archive_compressor_zstd_open(struct archive_write_filter *f) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_add_filter_zstd.c (-2 / +1 lines)
372	}	372	}
373	data->out.size = bs;	373	data->out.size = bs;
374	data->out.pos = 0;	374	data->out.pos = 0;
375	data->out.dst	375	data->out.dst = malloc(data->out.size);
376	= (unsigned char *)malloc(data->out.size);
377	if (data->out.dst == NULL) {	376	if (data->out.dst == NULL) {
378	archive_set_error(f->archive, ENOMEM,	377	archive_set_error(f->archive, ENOMEM,
379	"Can't allocate data for compression buffer");	378	"Can't allocate data for compression buffer");




{
	struct archive_write_disk *a;

	a = calloc(1, sizeof(*a));
	if (a == NULL)
		return (NULL);
	a->archive.magic = ARCHIVE_WRITE_DISK_MAGIC;

{
	struct fixup_entry *fe;

	fe = calloc(1, sizeof(struct fixup_entry));
	if (fe == NULL) {
		archive_set_error(&a->archive, ENOMEM,
		    "Can't allocate memory for a fixup");

	}
	for (xattr_i = 0; xattr_i < xattr_size;
	    xattr_i += strlen(xattr_names + xattr_i) + 1) {
		char *p;
		ssize_t s;
		int f;


			ret = ARCHIVE_WARN;
			goto exit_xattr;
		}
		p = realloc(xattr_val, s);
		if (p == NULL) {
		if (xattr_val == NULL) {
			archive_set_error(&a->archive, ENOMEM,
			    "Failed to get metadata(xattr)");
			ret = ARCHIVE_WARN;
			free(xattr_val_saved);
			goto exit_xattr;
		}
		xattr_val = p;
		s = fgetxattr(tmpfd, xattr_names + xattr_i, xattr_val, s, 0, 0);
		if (s == -1) {
			archive_set_error(&a->archive, errno,

	 * silly dance of writing the data to disk just so that
	 * copyfile() can read it back in again. */
	archive_string_init(&tmp);
	archive_strcpy(&tmp, "tar.mmd.XXXXXX");
	archive_strcat(&tmp, ".XXXXXX");
	fd = mkstemp(tmp.s);

	if (fd < 0) {

Lines 62-68 archive_write_open_fd(struct archive *a, int fd) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_open_fd.c (-1 / +1 lines)
62	{	62	{
63	struct write_fd_data *mine;	63	struct write_fd_data *mine;
64		64
65	mine = (struct write_fd_data )malloc(sizeof(mine));	65	mine = malloc(sizeof(*mine));
66	if (mine == NULL) {	66	if (mine == NULL) {
67	archive_set_error(a, ENOMEM, "No memory");	67	archive_set_error(a, ENOMEM, "No memory");
68	return (ARCHIVE_FATAL);	68	return (ARCHIVE_FATAL);

Lines 59-65 archive_write_open_FILE(struct archive a, FILE f) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_open_file.c (-1 / +1 lines)
59	{	59	{
60	struct write_FILE_data *mine;	60	struct write_FILE_data *mine;
61		61
62	mine = (struct write_FILE_data )malloc(sizeof(mine));	62	mine = malloc(sizeof(*mine));
63	if (mine == NULL) {	63	if (mine == NULL) {
64	archive_set_error(a, ENOMEM, "No memory");	64	archive_set_error(a, ENOMEM, "No memory");
65	return (ARCHIVE_FATAL);	65	return (ARCHIVE_FATAL);

Lines 98-104 open_filename(struct archive a, int mbs_fn, const void filename) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_open_filename.c (-1 / +1 lines)
98	struct write_file_data *mine;	98	struct write_file_data *mine;
99	int r;	99	int r;
100		100
101	mine = (struct write_file_data )calloc(1, sizeof(mine));	101	mine = calloc(1, sizeof(*mine));
102	if (mine == NULL) {	102	if (mine == NULL) {
103	archive_set_error(a, ENOMEM, "No memory");	103	archive_set_error(a, ENOMEM, "No memory");
104	return (ARCHIVE_FATAL);	104	return (ARCHIVE_FATAL);

Lines 52-58 archive_write_open_memory(struct archive a, void buff, size_t buffSize, size_t Link Here

(-)b/contrib/libarchive/libarchive/archive_write_open_memory.c (-1 / +1 lines)
52	{	52	{
53	struct write_memory_data *mine;	53	struct write_memory_data *mine;
54		54
55	mine = (struct write_memory_data )calloc(1, sizeof(mine));	55	mine = calloc(1, sizeof(*mine));
56	if (mine == NULL) {	56	if (mine == NULL) {
57	archive_set_error(a, ENOMEM, "No memory");	57	archive_set_error(a, ENOMEM, "No memory");
58	return (ARCHIVE_FATAL);	58	return (ARCHIVE_FATAL);




	 */
	if (archive_entry_filetype(entry) == AE_IFLNK) {
		ssize_t bytes;
		const void *p = (const void *)archive_entry_symlink_utf8(entry);
		bytes = compress_out(a, p, (size_t)file->size, ARCHIVE_Z_RUN);
		if (bytes < 0)
			return ((int)bytes);

		archive_entry_set_size(entry, 0);
	if (archive_entry_filetype(entry) == AE_IFDIR)
		file->dir = 1;
	else if (archive_entry_filetype(entry) == AE_IFLNK) {
		const char* linkpath;
		linkpath = archive_entry_symlink_utf8(entry);
		if (linkpath == NULL) {
			free(file);
			archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
			    "symlink path could not be converted to UTF-8");
			return (ARCHIVE_FAILED);
		}
		else
			file->size = strlen(linkpath);
	}
	if (archive_entry_mtime_is_set(entry)) {
		file->flg |= MTIME_IS_SET;
		file->times[MTIME].time = archive_entry_mtime(entry);




	if (a->format_free != NULL)
		(a->format_free)(a);

	ar = calloc(1, sizeof(*ar));
	if (ar == NULL) {
		archive_set_error(&a->archive, ENOMEM, "Can't allocate ar data");
		return (ARCHIVE_FATAL);

				return (ARCHIVE_WARN);
			}

			se = malloc(strlen(filename) + 3);
			if (se == NULL) {
				archive_set_error(&a->archive, ENOMEM,
				    "Can't allocate filename buffer");

			return (ARCHIVE_WARN);
		}

		ar->strtab = malloc(s + 1);
		if (ar->strtab == NULL) {
			archive_set_error(&a->archive, ENOMEM,
			    "Can't allocate strtab buffer");

Lines 185-191 archive_write_set_format_cpio_binary(struct archive *_a, int format) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_set_format_cpio_binary.c (-1 / +4 lines)
185	if (a->format_free != NULL)	185	if (a->format_free != NULL)
186	(a->format_free)(a);	186	(a->format_free)(a);
187		187
188	cpio = (struct cpio )calloc(1, sizeof(cpio));	188	cpio = calloc(1, sizeof(*cpio));
189	if (cpio == NULL) {	189	if (cpio == NULL) {
190	archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data");	190	archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data");
191	return (ARCHIVE_FATAL);	191	return (ARCHIVE_FATAL);
Lines 577-582 archive_write_binary_close(struct archive_write *a) Link Here
577	struct archive_entry *trailer;	577	struct archive_entry *trailer;
578		578
579	trailer = archive_entry_new2(NULL);	579	trailer = archive_entry_new2(NULL);
		580	if (trailer == NULL) {
		581	return ARCHIVE_FATAL;
		582	}
580	/* nlink = 1 here for GNU cpio compat. */	583	/* nlink = 1 here for GNU cpio compat. */
581	archive_entry_set_nlink(trailer, 1);	584	archive_entry_set_nlink(trailer, 1);
582	archive_entry_set_size(trailer, 0);	585	archive_entry_set_size(trailer, 0);

Lines 116-122 archive_write_set_format_cpio_newc(struct archive *_a) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_set_format_cpio_newc.c (-1 / +1 lines)
116	if (a->format_free != NULL)	116	if (a->format_free != NULL)
117	(a->format_free)(a);	117	(a->format_free)(a);
118		118
119	cpio = (struct cpio )calloc(1, sizeof(cpio));	119	cpio = calloc(1, sizeof(*cpio));
120	if (cpio == NULL) {	120	if (cpio == NULL) {
121	archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data");	121	archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data");
122	return (ARCHIVE_FATAL);	122	return (ARCHIVE_FATAL);

Lines 110-116 archive_write_set_format_cpio_odc(struct archive *_a) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_set_format_cpio_odc.c (-1 / +4 lines)
110	if (a->format_free != NULL)	110	if (a->format_free != NULL)
111	(a->format_free)(a);	111	(a->format_free)(a);
112		112
113	cpio = (struct cpio )calloc(1, sizeof(cpio));	113	cpio = calloc(1, sizeof(*cpio));
114	if (cpio == NULL) {	114	if (cpio == NULL) {
115	archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data");	115	archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data");
116	return (ARCHIVE_FATAL);	116	return (ARCHIVE_FATAL);
Lines 467-472 archive_write_odc_close(struct archive_write *a) Link Here
467	struct archive_entry *trailer;	467	struct archive_entry *trailer;
468		468
469	trailer = archive_entry_new2(NULL);	469	trailer = archive_entry_new2(NULL);
		470	if (trailer == NULL) {
		471	return ARCHIVE_FATAL;
		472	}
470	/* nlink = 1 here for GNU cpio compat. */	473	/* nlink = 1 here for GNU cpio compat. */
471	archive_entry_set_nlink(trailer, 1);	474	archive_entry_set_nlink(trailer, 1);
472	archive_entry_set_size(trailer, 0);	475	archive_entry_set_size(trailer, 0);




	struct archive_write *a = (struct archive_write *)_a;
	struct gnutar *gnutar;

	gnutar = calloc(1, sizeof(*gnutar));
	if (gnutar == NULL) {
		archive_set_error(&a->archive, ENOMEM,
		    "Can't allocate gnutar data");

	/* Only regular files (not hardlinks) have data. */
	if (archive_entry_hardlink(entry) != NULL ||
	    archive_entry_symlink(entry) != NULL ||
	    archive_entry_filetype(entry) != AE_IFREG)
		archive_entry_set_size(entry, 0);

	if (AE_IFDIR == archive_entry_filetype(entry)) {

			goto exit_write_header;
	}

	if (archive_entry_hardlink_is_set(entry)) {
		tartype = '1';
	} else
		switch (archive_entry_filetype(entry)) {

Lines 2237-2243 set_str_utf16be(struct archive_write a, unsigned char p, const char *s, Link Here

(-)b/contrib/libarchive/libarchive/archive_write_set_format_iso9660.c (-1 / +1 lines)
2237	int onepad;	2237	int onepad;
2238		2238
2239	if (s == NULL)	2239	if (s == NULL)
2240	s = "";	2240	s = "\0\0";
2241	if (l & 0x01) {	2241	if (l & 0x01) {
2242	onepad = 1;	2242	onepad = 1;
2243	l &= ~1;	2243	l &= ~1;

Lines 138-144 archive_write_set_format_pax(struct archive *_a) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_set_format_pax.c (-4 / +20 lines)
138	if (a->format_free != NULL)	138	if (a->format_free != NULL)
139	(a->format_free)(a);	139	(a->format_free)(a);
140		140
141	pax = (struct pax )calloc(1, sizeof(pax));	141	pax = calloc(1, sizeof(*pax));
142	if (pax == NULL) {	142	if (pax == NULL) {
143	archive_set_error(&a->archive, ENOMEM,	143	archive_set_error(&a->archive, ENOMEM,
144	"Can't allocate pax data");	144	"Can't allocate pax data");
Lines 608-614 archive_write_pax_header(struct archive_write *a, Link Here
608	const time_t ustar_max_mtime = get_ustar_max_mtime();	608	const time_t ustar_max_mtime = get_ustar_max_mtime();
609		609
610	/* Sanity check. */	610	/* Sanity check. */
		611	#if defined(_WIN32) && !defined(__CYGWIN__)
		612	/* NOTE: If the caller supplied a pathname that fails WCS conversion (e.g.
		613	* if it is invalid UTF-8), we are expected to return ARCHIVE_WARN later on
		614	* in execution, hence the check for both pointers */
		615	if ((archive_entry_pathname_w(entry_original) == NULL) &&
		616	(archive_entry_pathname(entry_original) == NULL)) {
		617	#else
611	if (archive_entry_pathname(entry_original) == NULL) {	618	if (archive_entry_pathname(entry_original) == NULL) {
		619	#endif
612	archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,	620	archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
613	"Can't record entry in tar file without pathname");	621	"Can't record entry in tar file without pathname");
614	return (ARCHIVE_FAILED);	622	return (ARCHIVE_FAILED);
Lines 1032-1037 archive_write_pax_header(struct archive_write *a, Link Here
1032	archive_entry_set_symlink(entry_main,	1040	archive_entry_set_symlink(entry_main,
1033	"././@LongSymLink");	1041	"././@LongSymLink");
1034	}	1042	}
		1043	else {
		1044	/* Otherwise, has non-ASCII characters; update the paths to
		1045	* however they got decoded above */
		1046	if (hardlink != NULL)
		1047	archive_entry_set_hardlink(entry_main, linkpath);
		1048	else
		1049	archive_entry_set_symlink(entry_main, linkpath);
		1050	}
1035	need_extension = 1;	1051	need_extension = 1;
1036	}	1052	}
1037	}	1053	}
Lines 1928-1934 url_encode(const char *in) Link Here
1928	}	1944	}
1929	}	1945	}
1930		1946
1931	out = (char *)malloc(out_len + 1);	1947	out = malloc(out_len + 1);
1932	if (out == NULL)	1948	if (out == NULL)
1933	return (NULL);	1949	return (NULL);
1934		1950
Lines 1966-1972 base64_encode(const char *s, size_t len) Link Here
1966	char d, out;	1982	char d, out;
1967		1983
1968	/* 3 bytes becomes 4 chars, but round up and allow for trailing NUL */	1984	/* 3 bytes becomes 4 chars, but round up and allow for trailing NUL */
1969	out = (char )malloc((len 4 + 2) / 3 + 1);	1985	out = malloc((len * 4 + 2) / 3 + 1);
1970	if (out == NULL)	1986	if (out == NULL)
1971	return (NULL);	1987	return (NULL);
1972	d = out;	1988	d = out;
Lines 2021-2027 _sparse_list_add_block(struct pax *pax, int64_t offset, int64_t length, Link Here
2021	{	2037	{
2022	struct sparse_block *sb;	2038	struct sparse_block *sb;
2023		2039
2024	sb = (struct sparse_block )malloc(sizeof(sb));	2040	sb = malloc(sizeof(*sb));
2025	if (sb == NULL)	2041	if (sb == NULL)
2026	return (ARCHIVE_FATAL);	2042	return (ARCHIVE_FATAL);
2027	sb->next = NULL;	2043	sb->next = NULL;

Lines 58-64 archive_write_set_format_raw(struct archive *_a) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_set_format_raw.c (-1 / +1 lines)
58	if (a->format_free != NULL)	58	if (a->format_free != NULL)
59	(a->format_free)(a);	59	(a->format_free)(a);
60		60
61	raw = (struct raw )calloc(1, sizeof(raw));	61	raw = calloc(1, sizeof(*raw));
62	if (raw == NULL) {	62	if (raw == NULL) {
63	archive_set_error(&a->archive, ENOMEM, "Can't allocate raw data");	63	archive_set_error(&a->archive, ENOMEM, "Can't allocate raw data");
64	return (ARCHIVE_FATAL);	64	return (ARCHIVE_FATAL);

Lines 113-119 archive_write_set_format_shar(struct archive *_a) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_set_format_shar.c (-1 / +9 lines)
113	if (a->format_free != NULL)	113	if (a->format_free != NULL)
114	(a->format_free)(a);	114	(a->format_free)(a);
115		115
116	shar = (struct shar )calloc(1, sizeof(shar));	116	shar = calloc(1, sizeof(*shar));
117	if (shar == NULL) {	117	if (shar == NULL) {
118	archive_set_error(&a->archive, ENOMEM, "Can't allocate shar data");	118	archive_set_error(&a->archive, ENOMEM, "Can't allocate shar data");
119	return (ARCHIVE_FATAL);	119	return (ARCHIVE_FATAL);
Lines 209-214 archive_write_shar_header(struct archive_write a, struct archive_entry entry) Link Here
209	if (archive_entry_filetype(entry) != AE_IFDIR) {	209	if (archive_entry_filetype(entry) != AE_IFDIR) {
210	/* Try to create the dir. */	210	/* Try to create the dir. */
211	p = strdup(name);	211	p = strdup(name);
		212	if (p == NULL) {
		213	archive_set_error(&a->archive, ENOMEM, "Out of memory");
		214	return (ARCHIVE_FATAL);
		215	}
212	pp = strrchr(p, '/');	216	pp = strrchr(p, '/');
213	/* If there is a / character, try to create the dir. */	217	/* If there is a / character, try to create the dir. */
214	if (pp != NULL) {	218	if (pp != NULL) {
Lines 291-296 archive_write_shar_header(struct archive_write a, struct archive_entry entry) Link Here
291	free(shar->last_dir);	295	free(shar->last_dir);
292		296
293	shar->last_dir = strdup(name);	297	shar->last_dir = strdup(name);
		298	if (shar->last_dir == NULL) {
		299	archive_set_error(&a->archive, ENOMEM, "Out of memory");
		300	return (ARCHIVE_FATAL);
		301	}
294	/* Trim a trailing '/'. */	302	/* Trim a trailing '/'. */
295	pp = strrchr(shar->last_dir, '/');	303	pp = strrchr(shar->last_dir, '/');
296	if (pp != NULL && pp[1] == '\0')	304	if (pp != NULL && pp[1] == '\0')

Lines 183-189 archive_write_set_format_ustar(struct archive *_a) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_set_format_ustar.c (-2 / +6 lines)
183	return (ARCHIVE_FATAL);	183	return (ARCHIVE_FATAL);
184	}	184	}
185		185
186	ustar = (struct ustar )calloc(1, sizeof(ustar));	186	ustar = calloc(1, sizeof(*ustar));
187	if (ustar == NULL) {	187	if (ustar == NULL) {
188	archive_set_error(&a->archive, ENOMEM,	188	archive_set_error(&a->archive, ENOMEM,
189	"Can't allocate ustar data");	189	"Can't allocate ustar data");
Lines 254-260 archive_write_ustar_header(struct archive_write a, struct archive_entry entry) Link Here
254	sconv = ustar->opt_sconv;	254	sconv = ustar->opt_sconv;
255		255
256	/* Sanity check. */	256	/* Sanity check. */
		257	#if defined(_WIN32) && !defined(__CYGWIN__)
		258	if (archive_entry_pathname_w(entry) == NULL) {
		259	#else
257	if (archive_entry_pathname(entry) == NULL) {	260	if (archive_entry_pathname(entry) == NULL) {
		261	#endif
258	archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,	262	archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
259	"Can't record entry in tar file without pathname");	263	"Can't record entry in tar file without pathname");
260	return (ARCHIVE_FAILED);	264	return (ARCHIVE_FAILED);
Lines 263-269 archive_write_ustar_header(struct archive_write a, struct archive_entry entry) Link Here
263	/* Only regular files (not hardlinks) have data. */	267	/* Only regular files (not hardlinks) have data. */
264	if (archive_entry_hardlink(entry) != NULL \|\|	268	if (archive_entry_hardlink(entry) != NULL \|\|
265	archive_entry_symlink(entry) != NULL \|\|	269	archive_entry_symlink(entry) != NULL \|\|
266	!(archive_entry_filetype(entry) == AE_IFREG))	270	archive_entry_filetype(entry) != AE_IFREG)
267	archive_entry_set_size(entry, 0);	271	archive_entry_set_size(entry, 0);
268		272
269	if (AE_IFDIR == archive_entry_filetype(entry)) {	273	if (AE_IFDIR == archive_entry_filetype(entry)) {

Lines 160-166 archive_write_set_format_v7tar(struct archive *_a) Link Here

(-)b/contrib/libarchive/libarchive/archive_write_set_format_v7tar.c (-2 / +2 lines)
160	return (ARCHIVE_FATAL);	160	return (ARCHIVE_FATAL);
161	}	161	}
162		162
163	v7tar = (struct v7tar )calloc(1, sizeof(v7tar));	163	v7tar = calloc(1, sizeof(*v7tar));
164	if (v7tar == NULL) {	164	if (v7tar == NULL) {
165	archive_set_error(&a->archive, ENOMEM,	165	archive_set_error(&a->archive, ENOMEM,
166	"Can't allocate v7tar data");	166	"Can't allocate v7tar data");
Lines 241-247 archive_write_v7tar_header(struct archive_write a, struct archive_entry entry) Link Here
241	/* Only regular files (not hardlinks) have data. */	241	/* Only regular files (not hardlinks) have data. */
242	if (archive_entry_hardlink(entry) != NULL \|\|	242	if (archive_entry_hardlink(entry) != NULL \|\|
243	archive_entry_symlink(entry) != NULL \|\|	243	archive_entry_symlink(entry) != NULL \|\|
244	!(archive_entry_filetype(entry) == AE_IFREG))	244	archive_entry_filetype(entry) != AE_IFREG)
245	archive_entry_set_size(entry, 0);	245	archive_entry_set_size(entry, 0);
246		246
247	if (AE_IFDIR == archive_entry_filetype(entry)) {	247	if (AE_IFDIR == archive_entry_filetype(entry)) {




		if (w > 0)
			xar->bytes_remaining -= w;
		else
			return ((int)w);
	}
	file = xar->cur_file;
	checksum_final(&(xar->e_sumwrk), &(file->data.e_sum));

	/*
	 * Make a file name entry, "<name>".
	 */
	l = ll = (int)archive_strlen(&(file->basename));
	tmp = malloc(l);
	if (tmp == NULL) {
		archive_set_error(&a->archive, ENOMEM,

			return (ARCHIVE_FATAL);
		}
		r = xmlTextWriterWriteBase64(writer, file->basename.s,
		    0, (int)archive_strlen(&(file->basename)));
		if (r < 0) {
			archive_set_error(&a->archive,
			    ARCHIVE_ERRNO_MISC,


	p = strchr(fn, '/');
	if (p == NULL) {
		if ((l = (int)strlen(fn)) == 0)
			return (0);
	} else
		l = (int)(p - fn);
	if (l > n -1)
		return (-1);
	memcpy(name, fn, l);

	 * of ugly hackery to convert a const * pointer to
	 * a non-const pointer. */
	strm->next_in = (Bytef *)(uintptr_t)(const void *)lastrm->next_in;
	strm->avail_in = (uInt)lastrm->avail_in;
	strm->total_in = (uLong)lastrm->total_in;
	strm->next_out = lastrm->next_out;
	strm->avail_out = (uInt)lastrm->avail_out;
	strm->total_out = (uLong)lastrm->total_out;
	if (deflateInit2(strm, level, Z_DEFLATED,
	    (withheader)?15:-15,

	 * of ugly hackery to convert a const * pointer to
	 * a non-const pointer. */
	strm->next_in = (Bytef *)(uintptr_t)(const void *)lastrm->next_in;
	strm->avail_in = (uInt)lastrm->avail_in;
	strm->total_in = (uLong)lastrm->total_in;
	strm->next_out = lastrm->next_out;
	strm->avail_out = (uInt)lastrm->avail_out;
	strm->total_out = (uLong)lastrm->total_out;
	r = deflate(strm,
	    (action == ARCHIVE_Z_FINISH)? Z_FINISH: Z_NO_FLUSH);

	 * of ugly hackery to convert a const * pointer to
	 * a non-const pointer. */
	strm->next_in = (char *)(uintptr_t)(const void *)lastrm->next_in;
	strm->avail_in = (unsigned int)lastrm->avail_in;
	strm->total_in_lo32 = (uint32_t)(lastrm->total_in & 0xffffffff);
	strm->total_in_hi32 = (uint32_t)(lastrm->total_in >> 32);
	strm->next_out = (char *)lastrm->next_out;
	strm->avail_out = (unsigned int)lastrm->avail_out;
	strm->total_out_lo32 = (uint32_t)(lastrm->total_out & 0xffffffff);
	strm->total_out_hi32 = (uint32_t)(lastrm->total_out >> 32);
	if (BZ2_bzCompressInit(strm, level, 0, 30) != BZ_OK) {

	 * of ugly hackery to convert a const * pointer to
	 * a non-const pointer. */
	strm->next_in = (char *)(uintptr_t)(const void *)lastrm->next_in;
	strm->avail_in = (unsigned int)lastrm->avail_in;
	strm->total_in_lo32 = (uint32_t)(lastrm->total_in & 0xffffffff);
	strm->total_in_hi32 = (uint32_t)(lastrm->total_in >> 32);
	strm->next_out = (char *)lastrm->next_out;
	strm->avail_out = (unsigned int)lastrm->avail_out;
	strm->total_out_lo32 = (uint32_t)(lastrm->total_out & 0xffffffff);
	strm->total_out_hi32 = (uint32_t)(lastrm->total_out >> 32);
	r = BZ2_bzCompress(strm,




	if (a->format_free != NULL)
		(a->format_free)(a);

	zip = calloc(1, sizeof(*zip));
	if (zip == NULL) {
		archive_set_error(&a->archive, ENOMEM,
		    "Can't allocate zip data");

		const char *p;
		size_t len;

		if (archive_entry_pathname_l(zip->entry, &p, &len, sconv) != 0) {
			if (errno == ENOMEM) {
				archive_set_error(&a->archive, ENOMEM,
				    "Can't allocate memory for Pathname");

			archive_set_error(&a->archive,
			    ARCHIVE_ERRNO_FILE_FORMAT,
			    "Can't translate Pathname '%s' to %s",
			    archive_entry_pathname(zip->entry),
			    archive_string_conversion_charset_name(sconv));
			ret2 = ARCHIVE_WARN;
		}

		 * for filename.
		 */
		if (type == AE_IFLNK) {
			if (archive_entry_symlink_l(zip->entry, &p, &len, sconv)) {
				if (errno == ENOMEM) {
					archive_set_error(&a->archive, ENOMEM,
					    "Can't allocate memory "

			archive_le32enc(e, (uint32_t)archive_entry_ctime(entry));
			e += 4;
		}
		archive_le16enc(ut + 2, (uint16_t)(e - ut - 4));
	}

	/*




/*
 * Copyright (c) 2003-2018
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"

DEFINE_TEST(test_7zip_filename_encoding_UTF16_win)
{
#if !defined(_WIN32) || defined(__CYGWIN__)
	skipping("This test is meant to verify unicode string handling"
		" on Windows with UTF-16 names");
	return;
#else
	struct archive *a;
	struct archive_entry *entry;
	char buff[4096];
	size_t used;

	/*
	 * Don't call setlocale because we're verifying that the '_w' functions
	 * work as expected
	 */

	a = archive_write_new();
	assertEqualInt(ARCHIVE_OK, archive_write_set_format_7zip(a));
	assertEqualInt(ARCHIVE_OK,
	    archive_write_open_memory(a, buff, sizeof(buff), &used));

	/* Part 1: file */
	entry = archive_entry_new2(a);
	archive_entry_copy_pathname_w(entry, L"\u8868.txt");
	archive_entry_set_filetype(entry, AE_IFREG);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));

	/* Part 2: directory */
	archive_entry_clear(entry);
	archive_entry_copy_pathname_w(entry, L"\u8868");
	archive_entry_set_filetype(entry, AE_IFDIR);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));

	/* Part 3: symlink */
	archive_entry_clear(entry);
	archive_entry_set_pathname(entry, "link.txt");
	archive_entry_copy_symlink_w(entry, L"\u8868.txt");
	archive_entry_set_filetype(entry, AE_IFLNK);
	archive_entry_set_symlink_type(entry, AE_SYMLINK_TYPE_FILE);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));

	/* NOTE: 7zip does not support hardlinks */

	archive_entry_free(entry);
	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	/* Ensure that the archive contents can be read properly */
	/* NOTE: 7zip file contents are not in the order we wrote them! */
	a = archive_read_new();
	archive_read_support_format_all(a);
	archive_read_support_filter_all(a);
	assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7));

	/* Read part 3: symlink */
	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
	assertEqualWString(L"\u8868.txt", archive_entry_symlink_w(entry));

	/* Read part 1: file */
	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
	assertEqualWString(L"\u8868.txt", archive_entry_pathname_w(entry));

	/* Read part 2: directory */
	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
	/* NOTE: Trailing slash added automatically for us */
	assertEqualWString(L"\u8868/", archive_entry_pathname_w(entry));

	archive_read_free(a);
#endif
}




/*-SPDX-License-Identifier: BSD-2-Clause
 * Copyright (C) 2024 by наб <nabijaczleweli@nabijaczleweli.xyz>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"

static const char data[] = "!<arch>\narchivemount.1/ 0           0     0     644     0         `\n";


DEFINE_TEST(test_ar_mode)
{
	struct archive * ar = archive_read_new();
	assertEqualInt(archive_read_support_format_all(ar), ARCHIVE_OK);
	assertEqualInt(archive_read_open_memory(ar, data, sizeof(data) - 1), ARCHIVE_OK);

	struct archive_entry * entry;
	assertEqualIntA(ar, archive_read_next_header(ar, &entry), ARCHIVE_OK);
	assertEqualIntA(ar, archive_entry_mode(entry), S_IFREG | 0644);

	archive_read_free(ar);
}




static void
test_newer_ctime_than_file_mbs(void)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
	skipping("Can't set ctime on Windows");
	return;
#else
	struct archive *a;
	struct archive_entry *ae;
	struct archive *m;

#if defined(_WIN32) && !defined(__CYGWIN__)
        skipping("Can't set ctime on Windows");
        return;
#endif

	if (!assert((m = archive_match_new()) != NULL))
		return;
	if (!assert((ae = archive_entry_new()) != NULL)) {

	archive_read_free(a);
	archive_entry_free(ae);
	archive_match_free(m);
#endif
}

static void

static void
test_newer_ctime_than_file_wcs(void)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
	skipping("Can't set ctime on Windows");
	return;
#else
	struct archive *a;
	struct archive_entry *ae;
	struct archive *m;

#if defined(_WIN32) && !defined(__CYGWIN__)
        skipping("Can't set ctime on Windows");
        return;
#endif

	if (!assert((m = archive_match_new()) != NULL))
		return;
	if (!assert((ae = archive_entry_new()) != NULL)) {

	archive_read_free(a);
	archive_entry_free(ae);
	archive_match_free(m);
#endif
}

static void

static void
test_older_ctime_than_file_mbs(void)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
	skipping("Can't set ctime on Windows");
	return;
#else
	struct archive *a;
	struct archive_entry *ae;
	struct archive *m;

#if defined(_WIN32) && !defined(__CYGWIN__)
        skipping("Can't set ctime on Windows");
        return;
#endif

	if (!assert((m = archive_match_new()) != NULL))
		return;
	if (!assert((ae = archive_entry_new()) != NULL)) {

	archive_read_free(a);
	archive_entry_free(ae);
	archive_match_free(m);
#endif
}

static void

static void
test_older_ctime_than_file_wcs(void)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
	skipping("Can't set ctime on Windows");
	return;
#else
	struct archive *a;
	struct archive_entry *ae;
	struct archive *m;

#if defined(_WIN32) && !defined(__CYGWIN__)
        skipping("Can't set ctime on Windows");
        return;
#endif

	if (!assert((m = archive_match_new()) != NULL))
		return;
	if (!assert((ae = archive_entry_new()) != NULL)) {

	archive_read_free(a);
	archive_entry_free(ae);
	archive_match_free(m);
#endif
}

static void

static void
test_ctime_between_files_mbs(void)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
	skipping("Can't set ctime on Windows");
	return;
#else
	struct archive *a;
	struct archive_entry *ae;
	struct archive *m;

#if defined(_WIN32) && !defined(__CYGWIN__)
        skipping("Can't set ctime on Windows");
        return;
#endif

	if (!assert((m = archive_match_new()) != NULL))
		return;
	if (!assert((ae = archive_entry_new()) != NULL)) {

	archive_read_free(a);
	archive_entry_free(ae);
	archive_match_free(m);
#endif
}

static void
test_ctime_between_files_wcs(void)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
	skipping("Can't set ctime on Windows");
	return;
#else
	struct archive *a;
	struct archive_entry *ae;
	struct archive *m;

#if defined(_WIN32) && !defined(__CYGWIN__)
        skipping("Can't set ctime on Windows");
        return;
#endif

	if (!assert((m = archive_match_new()) != NULL))
		return;
	if (!assert((ae = archive_entry_new()) != NULL)) {

	archive_read_free(a);
	archive_entry_free(ae);
	archive_match_free(m);
#endif
}

static void




/*-
 * Copyright (c) 2024 Tobias Stoeckmann
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "test.h"

#define __LIBARCHIVE_TEST
#include "archive_read_private.h"

static char buf[1024];

DEFINE_TEST(test_archive_read_ahead_eof)
{
	struct archive *a;
	struct archive_read *ar;
	ssize_t avail;

	/* prepare a reader of raw in-memory data */
	assert((a = archive_read_new()) != NULL);
	ar = (struct archive_read *)a;

	assertA(0 == archive_read_support_format_raw(a));
	assertA(0 == archive_read_open_memory(a, buf, sizeof(buf)));

	/* perform a read which can be fulfilled */
	assert(NULL != __archive_read_ahead(ar, sizeof(buf) - 1, &avail));
	assertEqualInt(sizeof(buf), avail);

	/* perform a read which cannot be fulfilled due to EOF */
	assert(NULL == __archive_read_ahead(ar, sizeof(buf) + 1, &avail));
	assertEqualInt(sizeof(buf), avail);

	/* perform the same read again */
	assert(NULL == __archive_read_ahead(ar, sizeof(buf) + 1, &avail));
	assertEqualInt(sizeof(buf), avail);

	/* perform another read which can be fulfilled */
	assert(NULL != __archive_read_ahead(ar, sizeof(buf), &avail));
	assertEqualInt(sizeof(buf), avail);

	assert(0 == archive_read_free(a));
}




    mydata->fd = open(mydata->filename, O_RDONLY | O_BINARY);
    if (mydata->fd >= 0)
    {
      if ((mydata->buffer = calloc(BLOCK_SIZE, 1)) == NULL)
        return (ARCHIVE_FAILED);
    }
  }


  for (i = 0; filename != NULL;)
  {
    assert((mydata = calloc(1, sizeof(*mydata))) != NULL);
    if (mydata == NULL) {
      assertEqualInt(ARCHIVE_OK, archive_read_free(a));
      return;
    }
    assert((mydata->filename = strdup(filename)) != NULL);
      (char *)calloc(strlen(filename) + 1, sizeof(char))) != NULL);
    if (mydata->filename == NULL) {
      free(mydata);
      assertEqualInt(ARCHIVE_OK, archive_read_free(a));
      return;
    }
    strcpy(mydata->filename, filename);
    mydata->fd = -1;
    filename = reffiles[++i];
    assertA(0 == archive_read_append_callback_data(a, mydata));
  }
  assertA(0 == archive_read_set_open_callback(a, file_open));
  assertA(0 == archive_read_set_read_callback(a, file_read));
  assertA(0 == archive_read_set_skip_callback(a, file_skip));
  assertA(0 == archive_read_set_close_callback(a, file_close));
  assertA(0 == archive_read_set_switch_callback(a, file_switch));
  assertA(0 == archive_read_set_seek_callback(a, file_seek));
  assertA(0 == archive_read_open1(a));


Lines 405-411 DEFINE_TEST(test_archive_string_sort) Link Here

(-)b/contrib/libarchive/libarchive/test/test_archive_string.c (-1 / +1 lines)
405		405
406	srand((unsigned int)time(NULL));	406	srand((unsigned int)time(NULL));
407	size = sizeof(strings) / sizeof(char *);	407	size = sizeof(strings) / sizeof(char *);
408	assert((test_strings = (char *)calloc(size, sizeof(char ))) != NULL);	408	assert((test_strings = calloc(size, sizeof(char *))) != NULL);
409	for (i = 0; i < (size - 1); i++)	409	for (i = 0; i < (size - 1); i++)
410	assert((test_strings[i] = strdup(strings[i])) != NULL);	410	assert((test_strings[i] = strdup(strings[i])) != NULL);
411		411




	test_archive_string_canonicalization();
	test_archive_string_set_get();
}

DEFINE_TEST(test_archive_string_conversion_utf16_utf8)
{
#if !defined(_WIN32) || defined(__CYGWIN__)
	skipping("This test is meant to verify unicode string handling on Windows");
#else
	struct archive_mstring mstr;
	const char* utf8_string;

	memset(&mstr, 0, sizeof(mstr));

	assertEqualInt(ARCHIVE_OK,
	    archive_mstring_copy_wcs(&mstr, L"\U0000043f\U00000440\U00000438"));

	/* Conversion from WCS to UTF-8 should always succeed */
	assertEqualInt(ARCHIVE_OK,
	    archive_mstring_get_utf8(NULL, &mstr, &utf8_string));
	assertEqualString("\xD0\xBF\xD1\x80\xD0\xB8", utf8_string);

	archive_mstring_clean(&mstr);
#endif
}

DEFINE_TEST(test_archive_string_conversion_utf8_utf16)
{
#if !defined(_WIN32) || defined(__CYGWIN__)
	skipping("This test is meant to verify unicode string handling on Windows");
#else
	struct archive_mstring mstr;
	const wchar_t* wcs_string;

	memset(&mstr, 0, sizeof(mstr));

	assertEqualInt(6,
	    archive_mstring_copy_utf8(&mstr, "\xD0\xBF\xD1\x80\xD0\xB8"));

	/* Conversion from UTF-8 to WCS should always succeed */
	assertEqualInt(ARCHIVE_OK,
	    archive_mstring_get_wcs(NULL, &mstr, &wcs_string));
	assertEqualWString(L"\U0000043f\U00000440\U00000438", wcs_string);

	archive_mstring_clean(&mstr);
#endif
}

DEFINE_TEST(test_archive_string_update_utf8_win)
{
#if !defined(_WIN32) || defined(__CYGWIN__)
	skipping("This test is meant to verify unicode string handling on Windows"
	    " with the C locale");
#else
	static const char utf8_string[] = "\xD0\xBF\xD1\x80\xD0\xB8";
	static const wchar_t wcs_string[] = L"\U0000043f\U00000440\U00000438";
	struct archive_mstring mstr;
	int r;

	memset(&mstr, 0, sizeof(mstr));

	r = archive_mstring_update_utf8(NULL, &mstr, utf8_string);

	/* On Windows, this should reliably fail with the C locale */
	assertEqualInt(-1, r);
	assertEqualInt(0, mstr.aes_set & AES_SET_MBS);

	/* NOTE: We access the internals to validate that they were set by the
	 *       'archive_mstring_update_utf8' function */
	/* UTF-8 should always be set */
	assertEqualInt(AES_SET_UTF8, mstr.aes_set & AES_SET_UTF8);
	assertEqualString(utf8_string, mstr.aes_utf8.s);
	/* WCS should always be set as well */
	assertEqualInt(AES_SET_WCS, mstr.aes_set & AES_SET_WCS);
	assertEqualWString(wcs_string, mstr.aes_wcs.s);

	archive_mstring_clean(&mstr);
#endif
}

DEFINE_TEST(test_archive_string_update_utf8_utf8)
{
	static const char utf8_string[] = "\xD0\xBF\xD1\x80\xD0\xB8";
	static const wchar_t wcs_string[] = L"\U0000043f\U00000440\U00000438";
	struct archive_mstring mstr;
	int r;

	memset(&mstr, 0, sizeof(mstr));

	if (setlocale(LC_ALL, "en_US.UTF-8") == NULL) {
		skipping("UTF-8 not supported on this system.");
		return;
	}

	r = archive_mstring_update_utf8(NULL, &mstr, utf8_string);

	/* All conversions should have succeeded */
	assertEqualInt(0, r);
	assertEqualInt(AES_SET_MBS | AES_SET_WCS | AES_SET_UTF8, mstr.aes_set);
	assertEqualString(utf8_string, mstr.aes_utf8.s);
	assertEqualString(utf8_string, mstr.aes_mbs.s);
	assertEqualWString(wcs_string, mstr.aes_wcs.s);

	archive_mstring_clean(&mstr);
}

DEFINE_TEST(test_archive_string_update_utf8_koi8)
{
	static const char utf8_string[] = "\xD0\xBF\xD1\x80\xD0\xB8";
	static const char koi8_string[] = "\xD0\xD2\xC9";
	static const wchar_t wcs_string[] = L"\U0000043f\U00000440\U00000438";
	struct archive_mstring mstr;
	int r;

	memset(&mstr, 0, sizeof(mstr));

	if (setlocale(LC_ALL, "ru_RU.KOI8-R") == NULL) {
		skipping("KOI8-R locale not available on this system.");
		return;
	}

	r = archive_mstring_update_utf8(NULL, &mstr, utf8_string);

	/* All conversions should have succeeded */
	assertEqualInt(0, r);
	assertEqualInt(AES_SET_MBS | AES_SET_WCS | AES_SET_UTF8, mstr.aes_set);
	assertEqualString(utf8_string, mstr.aes_utf8.s);
	assertEqualString(koi8_string, mstr.aes_mbs.s);
#if defined(_WIN32) && !defined(__CYGWIN__)
	assertEqualWString(wcs_string, mstr.aes_wcs.s);
#else
	/* No guarantee of how WCS strings behave, however this test test is
	 * primarily meant for Windows */
	(void)wcs_string;
#endif

	archive_mstring_clean(&mstr);
}

Lines 36-42 test_filter_by_name(const char *filter_name, int filter_code, Link Here

(-)b/contrib/libarchive/libarchive/test/test_archive_write_add_filter_by_name.c (-1 / +1 lines)
36	char *buff;	36	char *buff;
37	int r;	37	int r;
38		38
39	assert((buff = calloc(buffsize, sizeof(char))) != NULL);	39	assert((buff = calloc(buffsize, sizeof(*buff))) != NULL);
40	if (buff == NULL)	40	if (buff == NULL)
41	return;	41	return;
42		42

Lines 47-53 echo "f3" > $dir/d1/f3 Link Here

(-)b/contrib/libarchive/libarchive/test/test_compat_lzip.c (-1 / +1 lines)
47	rm -r $dir	47	rm -r $dir
48	}	48	}
49	#	49	#
50	# Make a lzip file from splitted tar file.	50	# Make a lzip file from split tar file.
51	#	51	#
52	name=test_compat_lzip_1	52	name=test_compat_lzip_1
53	dir="$name`date +%Y%m%d%H%M%S`.$USER"	53	dir="$name`date +%Y%m%d%H%M%S`.$USER"

Lines 60-66 test_compat_solaris_pax_sparse_1(void) Link Here

(-)b/contrib/libarchive/libarchive/test/test_compat_solaris_pax_sparse.c (-1 / +1 lines)
60	assertEqualInt(0100644, archive_entry_mode(ae));	60	assertEqualInt(0100644, archive_entry_mode(ae));
61		61
62	/* Verify the sparse information. */	62	/* Verify the sparse information. */
63	failure("This sparse file should have tree data blocks");	63	failure("This sparse file should have three data blocks");
64	assertEqualInt(3, archive_entry_sparse_reset(ae));	64	assertEqualInt(3, archive_entry_sparse_reset(ae));
65	assertEqualInt(ARCHIVE_OK,	65	assertEqualInt(ARCHIVE_OK,
66	archive_entry_sparse_next(ae, &offset, &length));	66	archive_entry_sparse_next(ae, &offset, &length));




	archive_entry_set_hardlink(e, "hardlink");
	archive_entry_set_symlink(e, "symlink");
	archive_entry_set_link(e, "link");
	assertEqualString(archive_entry_hardlink(e), NULL);
	assertEqualString(archive_entry_symlink(e), "link");

	/* mode */

	archive_entry_set_rdev(e, 532);
	archive_entry_set_size(e, 987654321);
	archive_entry_copy_sourcepath(e, "source");
	archive_entry_set_symlink(e, "symlinkname");
	archive_entry_set_uid(e, 83);
	archive_entry_set_uname(e, "user");
	/* Add an ACL entry. */

	assertEqualInt(archive_entry_rdev(e2), 532);
	assertEqualInt(archive_entry_size(e2), 987654321);
	assertEqualString(archive_entry_sourcepath(e2), "source");
	assertEqualString(archive_entry_symlink(e2), NULL);
	assertEqualInt(archive_entry_uid(e2), 83);
	assertEqualString(archive_entry_uname(e2), "user");


	assertEqualInt(archive_entry_rdev(e2), 532);
	assertEqualInt(archive_entry_size(e2), 987654321);
	assertEqualString(archive_entry_sourcepath(e2), "source");
	assertEqualString(archive_entry_symlink(e2), NULL);
	assertEqualInt(archive_entry_uid(e2), 83);
	assertEqualString(archive_entry_uname(e2), "user");


	/* Release clone. */
	archive_entry_free(e2);

	/* Verify that symlink is copied over by `clone` */
	archive_entry_set_symlink(e, "symlinkpath");
	e2 = archive_entry_clone(e);
	assertEqualString(archive_entry_hardlink(e2), NULL);
	assertEqualString(archive_entry_symlink(e2), "symlinkpath");
	archive_entry_free(e2);

	/*
	 * Test clear() implementation.
	 */




	assertEqualMem(buff, "\xE8\xA1\xA8.txt", 7);
}

DEFINE_TEST(test_gnutar_filename_encoding_UTF16_win)
{
#if !defined(_WIN32) || defined(__CYGWIN__)
	skipping("This test is meant to verify unicode string handling"
		" on Windows with UTF-16 names");
	return;
#else
	struct archive *a;
	struct archive_entry *entry;
	char buff[4096];
	size_t used;

	/*
	 * Don't call setlocale because we're verifying that the '_w' functions
	 * work as expected when 'hdrcharset' is UTF-8
	 */

	/* Part 1: file */
	a = archive_write_new();
	assertEqualInt(ARCHIVE_OK, archive_write_set_format_gnutar(a));
	if (archive_write_set_options(a, "hdrcharset=UTF-8") != ARCHIVE_OK) {
		skipping("This system cannot convert character-set"
		    " from UTF-16 to UTF-8.");
		archive_write_free(a);
		return;
	}
	assertEqualInt(ARCHIVE_OK,
	    archive_write_open_memory(a, buff, sizeof(buff), &used));

	entry = archive_entry_new2(a);
	/* Set the filename using a UTF-16 string */
	archive_entry_copy_pathname_w(entry, L"\u8868.txt");
	archive_entry_set_filetype(entry, AE_IFREG);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
	archive_entry_free(entry);
	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	/* Check UTF-8 version. */
	assertEqualMem(buff, "\xE8\xA1\xA8.txt", 7);

	/* Part 2: directory */
	a = archive_write_new();
	assertEqualInt(ARCHIVE_OK, archive_write_set_format_gnutar(a));
	assertEqualInt(ARCHIVE_OK, archive_write_set_options(a, "hdrcharset=UTF-8"));
	assertEqualInt(ARCHIVE_OK,
	    archive_write_open_memory(a, buff, sizeof(buff), &used));

	entry = archive_entry_new2(a);
	/* Set the directory name using a UTF-16 string */
	/* NOTE: Explicitly not adding trailing slash to test that code path */
	archive_entry_copy_pathname_w(entry, L"\u8868");
	archive_entry_set_filetype(entry, AE_IFDIR);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
	archive_entry_free(entry);
	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	/* Check UTF-8 version. */
	assertEqualMem(buff, "\xE8\xA1\xA8/", 4);

	/* Part 3: symlink */
	a = archive_write_new();
	assertEqualInt(ARCHIVE_OK, archive_write_set_format_gnutar(a));
	assertEqualInt(ARCHIVE_OK, archive_write_set_options(a, "hdrcharset=UTF-8"));
	assertEqualInt(ARCHIVE_OK,
	    archive_write_open_memory(a, buff, sizeof(buff), &used));

	entry = archive_entry_new2(a);
	/* Set the symlink target using a UTF-16 string */
	archive_entry_set_pathname(entry, "link.txt");
	archive_entry_copy_symlink_w(entry, L"\u8868.txt");
	archive_entry_set_filetype(entry, AE_IFLNK);
	archive_entry_set_symlink_type(entry, AE_SYMLINK_TYPE_FILE);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
	archive_entry_free(entry);
	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	/* Check UTF-8 version. */
	assertEqualMem(buff + 157, "\xE8\xA1\xA8.txt", 7);

	/* Part 4: hardlink */
	a = archive_write_new();
	assertEqualInt(ARCHIVE_OK, archive_write_set_format_gnutar(a));
	assertEqualInt(ARCHIVE_OK, archive_write_set_options(a, "hdrcharset=UTF-8"));
	assertEqualInt(ARCHIVE_OK,
	    archive_write_open_memory(a, buff, sizeof(buff), &used));

	entry = archive_entry_new2(a);
	/* Set the symlink target using a UTF-16 string */
	archive_entry_set_pathname(entry, "link.txt");
	archive_entry_copy_hardlink_w(entry, L"\u8868.txt");
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
	archive_entry_free(entry);
	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	/* Check UTF-8 version. */
	assertEqualMem(buff + 157, "\xE8\xA1\xA8.txt", 7);
#endif
}




	test_linkify_old_cpio();
	test_linkify_new_cpio();
}

DEFINE_TEST(test_link_resolver_unicode_win)
{
#if !defined(_WIN32) || defined(__CYGWIN__)
	skipping("This test is meant to verify unicode string handling"
	    " on Windows with UTF-16 names");
	return;
#else
	struct archive_entry *entry, *e2;
	struct archive_entry_linkresolver *resolver;

	/* Initialize the resolver. */
	assert(NULL != (resolver = archive_entry_linkresolver_new()));
	archive_entry_linkresolver_set_strategy(resolver,
	    ARCHIVE_FORMAT_TAR_USTAR);

	/* Create an entry with a unicode filename and 2 links. */
	assert(NULL != (entry = archive_entry_new()));
	archive_entry_copy_pathname_w(entry, L"\u4f60\u597d.txt");
	archive_entry_set_ino(entry, 1);
	archive_entry_set_dev(entry, 2);
	archive_entry_set_nlink(entry, 2);
	archive_entry_set_size(entry, 10);
	archive_entry_linkify(resolver, &entry, &e2);

	/* Shouldn't be altered, since it wasn't seen before. */
	assert(e2 == NULL);
	assertEqualWString(L"\u4f60\u597d.txt", archive_entry_pathname_w(entry));
	assertEqualWString(NULL, archive_entry_hardlink_w(entry));
	assertEqualInt(10, archive_entry_size(entry));

	/* Link to the same file contents, but a new unicode name. */
	archive_entry_copy_pathname_w(entry, L"\u518d\u89c1.txt");
	archive_entry_linkify(resolver, &entry, &e2);

	/* Size & link path should have changed. */
	assert(e2 == NULL);
	assertEqualWString(L"\u518d\u89c1.txt", archive_entry_pathname_w(entry));
	assertEqualWString(L"\u4f60\u597d.txt", archive_entry_hardlink_w(entry));
	assertEqualInt(0, archive_entry_size(entry));

	archive_entry_free(entry);
	archive_entry_linkresolver_free(resolver);
#endif
}




	assertEqualInt(ARCHIVE_OK, archive_write_free(a));
}

/*
 * Verify that unicode filenames are correctly preserved on Windows
 */
DEFINE_TEST(test_pax_filename_encoding_UTF16_win)
{
#if !defined(_WIN32) || defined(__CYGWIN__)
	skipping("This test is meant to verify unicode string handling"
		" on Windows with UTF-16 names");
	return;
#else
	struct archive *a;
	struct archive_entry *entry;
	char buff[0x2000];
	char *p;
	size_t used;

	/*
	 * Don't call setlocale because we're verifying that the '_w' functions
	 * work as expected when 'hdrcharset' is UTF-8
	 */

	/* Check if the platform completely supports the string conversion. */
	a = archive_write_new();
	assertEqualInt(ARCHIVE_OK, archive_write_set_format_pax(a));
	if (archive_write_set_options(a, "hdrcharset=UTF-8") != ARCHIVE_OK) {
		skipping("This system cannot convert character-set"
		    " from UTF-16 to UTF-8.");
		archive_write_free(a);
		return;
	}
	archive_write_free(a);

	/*
	 * Create a new archive handle with default charset handling
	 */
	a = archive_write_new();
	assertEqualInt(ARCHIVE_OK, archive_write_set_format_pax(a));
	assertEqualInt(ARCHIVE_OK,
	    archive_write_open_memory(a, buff, sizeof(buff), &used));

	/* Part 1: file */
	entry = archive_entry_new2(a);
	archive_entry_copy_pathname_w(entry, L"\u4f60\u597d.txt");
	archive_entry_set_filetype(entry, AE_IFREG);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));

	/* Part 2: directory */
	/* NOTE: Explicitly not adding trailing slash to test that code path */
	archive_entry_copy_pathname_w(entry, L"\u043f\u0440\u0438");
	archive_entry_set_filetype(entry, AE_IFDIR);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));

	/* Part 3: symlink */
	archive_entry_copy_pathname_w(entry, L"\u518d\u89c1.txt");
	archive_entry_copy_symlink_w(entry, L"\u4f60\u597d.txt");
	archive_entry_set_filetype(entry, AE_IFLNK);
	archive_entry_set_symlink_type(entry, AE_SYMLINK_TYPE_FILE);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));

	/* Part 4: hardlink */
	archive_entry_copy_pathname_w(entry, L"\u665a\u5b89.txt");
	archive_entry_copy_hardlink_w(entry, L"\u4f60\u597d.txt");
	archive_entry_set_filetype(entry, AE_IFREG);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));

	archive_entry_free(entry);
	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	/*
	 * Examine the bytes to ensure the filenames ended up UTF-8
	 * encoded as we expect.
	 */

	/* Part 1: file */
	p = buff + 0;
	assertEqualString(p + 0, "PaxHeader/\xE4\xBD\xA0\xE5\xA5\xBD.txt"); /* File name */
	assertEqualInt(p[156], 'x'); /* Pax extension header */
	p += 512; /* Pax extension body */
	assertEqualString(p + 0, "19 path=\xE4\xBD\xA0\xE5\xA5\xBD.txt\n");
	p += 512; /* Ustar header */
	assertEqualString(p + 0, "\xE4\xBD\xA0\xE5\xA5\xBD.txt"); /* File name */
	assertEqualInt(p[156], '0');

	/* Part 2: directory */
	p += 512; /* Pax extension header */
	assertEqualString(p + 0, "PaxHeader/\xD0\xBF\xD1\x80\xD0\xB8"); /* File name */
	assertEqualInt(p[156], 'x');
	p += 512; /* Pax extension body */
	assertEqualString(p + 0, "16 path=\xD0\xBF\xD1\x80\xD0\xB8/\n");
	p += 512; /* Ustar header */
	assertEqualString(p + 0, "\xD0\xBF\xD1\x80\xD0\xB8/"); /* File name */
	assertEqualInt(p[156], '5'); /* directory */

	/* Part 3: symlink */
	p += 512; /* Pax Extension Header */
	assertEqualString(p + 0, "PaxHeader/\xE5\x86\x8D\xE8\xA7\x81.txt"); /* File name */
	p += 512; /* Pax extension body */
	assertEqualString(p + 0,
			  "19 path=\xE5\x86\x8D\xE8\xA7\x81.txt\n"
			  "23 linkpath=\xE4\xBD\xA0\xE5\xA5\xBD.txt\n"
			  "31 LIBARCHIVE.symlinktype=file\n");
	p += 512; /* Ustar header */
	assertEqualString(p + 0, "\xE5\x86\x8D\xE8\xA7\x81.txt"); /* File name */
	assertEqualInt(p[156], '2'); /* symlink */
	assertEqualString(p + 157, "\xE4\xBD\xA0\xE5\xA5\xBD.txt"); /* link name */

	/* Part 4: hardlink */
	p += 512; /* Pax extension header */
	assertEqualString(p + 0, "PaxHeader/\xE6\x99\x9A\xE5\xAE\x89.txt"); /* File name */
	p += 512; /* Pax extension body */
	assertEqualString(p + 0,
			  "19 path=\xE6\x99\x9A\xE5\xAE\x89.txt\n"
			  "23 linkpath=\xE4\xBD\xA0\xE5\xA5\xBD.txt\n"
			  "31 LIBARCHIVE.symlinktype=file\n");
	p += 512; /* Ustar header */
	assertEqualString(p + 0, "\xE6\x99\x9A\xE5\xAE\x89.txt"); /* File name */
	assertEqualInt(p[156], '1'); /* hard link */
	assertEqualString(p + 157, "\xE4\xBD\xA0\xE5\xA5\xBD.txt"); /* link name */

	/*
	 * Read back the archive to see if we get the original names
	 */
	a = archive_read_new();
	archive_read_support_format_all(a);
	archive_read_support_filter_all(a);
	assertEqualInt(0, archive_read_open_memory(a, buff, used));

	/* Read part 1: file */
	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
	assertEqualWString(L"\u4f60\u597d.txt", archive_entry_pathname_w(entry));

	/* Read part 2: directory */
	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
	assertEqualWString(L"\u043f\u0440\u0438/", archive_entry_pathname_w(entry));

	/* Read part 3: symlink */
	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
	assertEqualWString(L"\u518d\u89c1.txt", archive_entry_pathname_w(entry));
	assertEqualWString(L"\u4f60\u597d.txt", archive_entry_symlink_w(entry));

	/* Read part 4: hardlink */
	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
	assertEqualWString(L"\u665a\u5b89.txt", archive_entry_pathname_w(entry));
	assertEqualWString(L"\u4f60\u597d.txt", archive_entry_hardlink_w(entry));

	archive_free(a);
#endif
}

DEFINE_TEST(test_pax_filename_encoding)
{




/*-
 * Copyright (c) 2003-2024 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"

DEFINE_TEST(test_read_filter_gzip_recursive)
{
	const char *name = "test_read_filter_gzip_recursive.gz";
	struct archive *a;

	if (!canGzip()) {
		skipping("gzip not available");
		return;
	}

	assert((a = archive_read_new()) != NULL);
	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
	extract_reference_file(name);
	assertEqualIntA(a, ARCHIVE_FATAL,
	    archive_read_open_filename(a, name, 200));

	/* Verify that the filter detection worked. */
	assertEqualInt(archive_filter_code(a, 0), ARCHIVE_FILTER_GZIP);
	assertEqualString(archive_filter_name(a, 0), "gzip");

	assertEqualInt(ARCHIVE_OK, archive_read_close(a));
	assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}

Added Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_filter_gzip_recursive.gz.uu (+19 lines)
1	From oss-fuzz:
2
3	clusterfuzz-testcase-minimized-libarchive_fuzzer-5138261947580416
4
5	This is a gzip input that expands to a gzip, etc, in such a way that
6	the "filename" field in the nested gzip header ends up being extremely
7	large (> 500 MiB). This caused headaches for the gzip filter before I
8	implemented a sanity limit on filename and comment sizes.
9
10	begin 644 test_read_filter_gzip_recursive.gz
11	M'XL(`5`M[_<\`'#_``#_'XL("0!D0`GK_W,)&P!P_P``_Q^+"`@(`%$`"0D<
12	M`'#_``#_'XL($?\'_^_W/`!P_P``_Q^+"`D`9$`)Z_]S[AL`</\``/\?BP@(
13	M"`!1``D)'`!P_P``_Q^+"!'_!___ZP$)=Q'_!___<PD;`'#_``#_'XL("`@`
14	M40`)"1P`</\``/\?BP@1_P?_[_<\`'#_``#_'XL("0!D0`GK_SP`</\``/\?
15	MBP@)`&1`">O_<^YC:&$!"7<1_P?__W,)&P!P_P``_Q^+"`@(`%$`"0D<`'#_
16	M``#_'XL($?\'_^_W/`!P_P``_Q^+"`D`9$`)Z_\\@</"P\/#P\/#P\/!P\/#
17	7P\/#P\/#P\/EP\/#B`$`PT.?"`M=P\,`
18	`
19	end





	extract_reference_file(refname);

	assertEqualInt(ARCHIVE_OK, archive_read_free(a));
	assert((a = archive_read_new()) != NULL);
	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));


	extract_reference_file(refname);

	assertEqualInt(ARCHIVE_OK, archive_read_free(a));
	assert((a = archive_read_new()) != NULL);
	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));

	assertEqualString("system", archive_entry_fflags_text(ae));


	assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}

DEFINE_TEST(test_read_format_7zip_extract_second)
{
	struct archive *a;
	char buffer[256];

	assert((a = archive_read_new()) != NULL);

	if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
		skipping(
		    "7zip:lzma decoding is not supported on this platform");
		assertEqualInt(ARCHIVE_OK, archive_read_free(a));
		return;
	}

	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));

	/*
	 * The test archive has two files: first.txt which is a 65,536 file (the
	 * size of the uncompressed buffer), and second.txt which has contents
	 * we will validate. This test ensures we can skip first.txt and still
	 * be able to read the contents of second.txt
	 */
	const char *refname = "test_read_format_7zip_extract_second.7z";
	extract_reference_file(refname);

	assertEqualIntA(a, ARCHIVE_OK,
		archive_read_open_filename(a, refname, 10240));

	struct archive_entry *ae;

	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
	assertEqualString("first.txt", archive_entry_pathname(ae));

	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
	assertEqualString("second.txt", archive_entry_pathname(ae));

	assertEqualInt(23, archive_read_data(a, buffer, sizeof(buffer)));
	assertEqualMem("This is from second.txt", buffer, 23);

	assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}

Added Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_7zip_extract_second.7z.uu (+11 lines)
1	begin 644 test_read_format_7zip_extract_second.7z
2	M-WJ\KR<<``-N%=VX!@$````````B`````````*R\U.<`&`Q"DFIGO`[1,RO\
3	MN,RA7-QU1L&_]O_/$0MMLIEBUR3'BDX@M2C-5'VG./-4,5@W3Q@*__^7_,[H
4	MEO`DB'[ZI>@H2_E>/W.2G$$.P01-X!YN5";SS[3#7Z4Q1G/EF.0'^D*[S8&8
5	M[FV9DYX7,SA%^.Q\'?__P!@`````@3,'K@_4WV/Q0A7VLXG$X?GH4=5W^`UM
6	M$N_EX$)LE*?K$W5?WLP:X0T[Q%V^?A!0E\VZRBB,)(MO`C`LO[O!3(1YL)<:
7	MJ."`';WU;>GP5',%Z=6?/H9Z)&\*!2^<F\P&>,RV`R30UOBH8+5.;;2IKF
8	M0W://&'?"L?0L2!)`*]F30B0&/_'<4``%P9Z`0F`C``'"P$``2,#`0$%70``
9	-@``,@@`6]FB2D`````
10	`
11	end




0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
};

/*
 * XXX This must be removed when we use int64_t for uid.
 */
static int
uid_size(void)
{
	return (sizeof(uid_t));
}

DEFINE_TEST(test_read_format_cpio_afio)
{
	unsigned char *p;

	 */
	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
	assertEqualInt(17, archive_entry_size(ae));
	assertEqualInt(65536, archive_entry_uid(ae));
		assertEqualInt(65536, archive_entry_uid(ae));
	assertEqualInt(archive_entry_is_encrypted(ae), 0);
	assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
	assertA(archive_filter_code(a, 0) == ARCHIVE_FILTER_NONE);


	free(p);
}

// From OSS Fuzz Issue 70019:
static unsigned char archive2[] = "070727bbbBbbbBabbbbbbcbcbbbbbbm726f777f777ffffffff518402ffffbbbabDDDDDDDDD7c7Ddd7DDDDnDDDdDDDB7777s77777777777C7727:";

DEFINE_TEST(test_read_format_cpio_afio_broken)
{
	struct archive *a;
	struct archive_entry *ae;

	assert((a = archive_read_new()) != NULL);
	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
	assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, archive2, sizeof(archive2)));
	assertEqualIntA(a, ARCHIVE_FATAL, archive_read_next_header(a, &ae));
	assertEqualInt(archive_filter_code(a, 0), ARCHIVE_FILTER_NONE);
	assertEqualInt(archive_format(a), ARCHIVE_FORMAT_CPIO_AFIO_LARGE);
	archive_read_free(a);
}




/*-
 * Copyright (c) 2003-2024 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"

DEFINE_TEST(test_read_format_huge_rpm)
{
	struct archive_entry *ae;
	struct archive *a;
	const char *name = "test_read_format_huge_rpm.rpm";

	assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
	extract_reference_file(name);
	assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 2));

	/* This archive should have no entries -- if it has entries, the bid has screwed up */
	assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));

	/* Verify that the format detection worked. */
	assertEqualInt(ARCHIVE_FILTER_RPM, archive_filter_code(a, 0));
	assertEqualString("rpm", archive_filter_name(a, 0));
	assertEqualInt(ARCHIVE_FORMAT_EMPTY, archive_format(a));

	assertEqualInt(ARCHIVE_OK, archive_read_close(a));
	assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}


Added Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_huge_rpm.rpm.uu (+244 lines)
1	(
2	# set up ST_LEAD
3	python -c 'import sys; sys.stdout.buffer.write(b"\xED\xAB\xEE\xDB\x03\x00\x00\x01" + (96 - 8) * b"\x00")'
4	# set up ST_HEADER with 0x800000 sections
5	python -c 'import sys; sys.stdout.buffer.write(b"\x8E\xAD\xE8\x01" + 4 * b"\x00" + b"\x80" + 7 * b"\x00")'
6	# create archive
7	touch input.txt
8	bsdtar -cf - input.txt
9	) > test_read_format_huge_rpm.rpm
10
11	begin 644 test_read_format_huge_rpm.rpm
12	M[:ONVP,```$`````````````````````````````````````````````````
13	M````````````````````````````````````````````````````````````
14	M````````CJWH`0````"``````````&EN<'5T+G1X=```````````````````
15	M````````````````````````````````````````````````````````````
16	M```````````````````````````````````````````P,#`V-#0@`#`P,#<V
17	M-2``,#`P,#(T(``P,#`P,#`P,#`P,"`Q-#8Q-3(U-C0W-"`P,3(W,38`(#``
18	M````````````````````````````````````````````````````````````
19	M````````````````````````````````````````````````````````````
20	M````````````=7-T87(`,#!T:6T`````````````````````````````````
21	M`````'-T869F````````````````````````````````````,#`P,#`P(``P
22	M,#`P,#`@````````````````````````````````````````````````````
23	M````````````````````````````````````````````````````````````
24	M````````````````````````````````````````````````````````````
25	M````````````````````````````````````````````````````````````
26	M````````````````````````````````````````````````````````````
27	M````````````````````````````````````````````````````````````
28	M````````````````````````````````````````````````````````````
29	M````````````````````````````````````````````````````````````
30	M````````````````````````````````````````````````````````````
31	M````````````````````````````````````````````````````````````
32	M````````````````````````````````````````````````````````````
33	M````````````````````````````````````````````````````````````
34	M````````````````````````````````````````````````````````````
35	M````````````````````````````````````````````````````````````
36	M````````````````````````````````````````````````````````````
37	M````````````````````````````````````````````````````````````
38	M````````````````````````````````````````````````````````````
39	M````````````````````````````````````````````````````````````
40	M````````````````````````````````````````````````````````````
41	M````````````````````````````````````````````````````````````
42	M````````````````````````````````````````````````````````````
43	M````````````````````````````````````````````````````````````
44	M````````````````````````````````````````````````````````````
45	M````````````````````````````````````````````````````````````
46	M````````````````````````````````````````````````````````````
47	M````````````````````````````````````````````````````````````
48	M````````````````````````````````````````````````````````````
49	M````````````````````````````````````````````````````````````
50	M````````````````````````````````````````````````````````````
51	M````````````````````````````````````````````````````````````
52	M````````````````````````````````````````````````````````````
53	M````````````````````````````````````````````````````````````
54	M````````````````````````````````````````````````````````````
55	M````````````````````````````````````````````````````````````
56	M````````````````````````````````````````````````````````````
57	M````````````````````````````````````````````````````````````
58	M````````````````````````````````````````````````````````````
59	M````````````````````````````````````````````````````````````
60	M````````````````````````````````````````````````````````````
61	M````````````````````````````````````````````````````````````
62	M````````````````````````````````````````````````````````````
63	M````````````````````````````````````````````````````````````
64	M````````````````````````````````````````````````````````````
65	M````````````````````````````````````````````````````````````
66	M````````````````````````````````````````````````````````````
67	M````````````````````````````````````````````````````````````
68	M````````````````````````````````````````````````````````````
69	M````````````````````````````````````````````````````````````
70	M````````````````````````````````````````````````````````````
71	M````````````````````````````````````````````````````````````
72	M````````````````````````````````````````````````````````````
73	M````````````````````````````````````````````````````````````
74	M````````````````````````````````````````````````````````````
75	M````````````````````````````````````````````````````````````
76	M````````````````````````````````````````````````````````````
77	M````````````````````````````````````````````````````````````
78	M````````````````````````````````````````````````````````````
79	M````````````````````````````````````````````````````````````
80	M````````````````````````````````````````````````````````````
81	M````````````````````````````````````````````````````````````
82	M````````````````````````````````````````````````````````````
83	M````````````````````````````````````````````````````````````
84	M````````````````````````````````````````````````````````````
85	M````````````````````````````````````````````````````````````
86	M````````````````````````````````````````````````````````````
87	M````````````````````````````````````````````````````````````
88	M````````````````````````````````````````````````````````````
89	M````````````````````````````````````````````````````````````
90	M````````````````````````````````````````````````````````````
91	M````````````````````````````````````````````````````````````
92	M````````````````````````````````````````````````````````````
93	M````````````````````````````````````````````````````````````
94	M````````````````````````````````````````````````````````````
95	M````````````````````````````````````````````````````````````
96	M````````````````````````````````````````````````````````````
97	M````````````````````````````````````````````````````````````
98	M````````````````````````````````````````````````````````````
99	M````````````````````````````````````````````````````````````
100	M````````````````````````````````````````````````````````````
101	M````````````````````````````````````````````````````````````
102	M````````````````````````````````````````````````````````````
103	M````````````````````````````````````````````````````````````
104	M````````````````````````````````````````````````````````````
105	M````````````````````````````````````````````````````````````
106	M````````````````````````````````````````````````````````````
107	M````````````````````````````````````````````````````````````
108	M````````````````````````````````````````````````````````````
109	M````````````````````````````````````````````````````````````
110	M````````````````````````````````````````````````````````````
111	M````````````````````````````````````````````````````````````
112	M````````````````````````````````````````````````````````````
113	M````````````````````````````````````````````````````````````
114	M````````````````````````````````````````````````````````````
115	M````````````````````````````````````````````````````````````
116	M````````````````````````````````````````````````````````````
117	M````````````````````````````````````````````````````````````
118	M````````````````````````````````````````````````````````````
119	M````````````````````````````````````````````````````````````
120	M````````````````````````````````````````````````````````````
121	M````````````````````````````````````````````````````````````
122	M````````````````````````````````````````````````````````````
123	M````````````````````````````````````````````````````````````
124	M````````````````````````````````````````````````````````````
125	M````````````````````````````````````````````````````````````
126	M````````````````````````````````````````````````````````````
127	M````````````````````````````````````````````````````````````
128	M````````````````````````````````````````````````````````````
129	M````````````````````````````````````````````````````````````
130	M````````````````````````````````````````````````````````````
131	M````````````````````````````````````````````````````````````
132	M````````````````````````````````````````````````````````````
133	M````````````````````````````````````````````````````````````
134	M````````````````````````````````````````````````````````````
135	M````````````````````````````````````````````````````````````
136	M````````````````````````````````````````````````````````````
137	M````````````````````````````````````````````````````````````
138	M````````````````````````````````````````````````````````````
139	M````````````````````````````````````````````````````````````
140	M````````````````````````````````````````````````````````````
141	M````````````````````````````````````````````````````````````
142	M````````````````````````````````````````````````````````````
143	M````````````````````````````````````````````````````````````
144	M````````````````````````````````````````````````````````````
145	M````````````````````````````````````````````````````````````
146	M````````````````````````````````````````````````````````````
147	M````````````````````````````````````````````````````````````
148	M````````````````````````````````````````````````````````````
149	M````````````````````````````````````````````````````````````
150	M````````````````````````````````````````````````````````````
151	M````````````````````````````````````````````````````````````
152	M````````````````````````````````````````````````````````````
153	M````````````````````````````````````````````````````````````
154	M````````````````````````````````````````````````````````````
155	M````````````````````````````````````````````````````````````
156	M````````````````````````````````````````````````````````````
157	M````````````````````````````````````````````````````````````
158	M````````````````````````````````````````````````````````````
159	M````````````````````````````````````````````````````````````
160	M````````````````````````````````````````````````````````````
161	M````````````````````````````````````````````````````````````
162	M````````````````````````````````````````````````````````````
163	M````````````````````````````````````````````````````````````
164	M````````````````````````````````````````````````````````````
165	M````````````````````````````````````````````````````````````
166	M````````````````````````````````````````````````````````````
167	M````````````````````````````````````````````````````````````
168	M````````````````````````````````````````````````````````````
169	M````````````````````````````````````````````````````````````
170	M````````````````````````````````````````````````````````````
171	M````````````````````````````````````````````````````````````
172	M````````````````````````````````````````````````````````````
173	M````````````````````````````````````````````````````````````
174	M````````````````````````````````````````````````````````````
175	M````````````````````````````````````````````````````````````
176	M````````````````````````````````````````````````````````````
177	M````````````````````````````````````````````````````````````
178	M````````````````````````````````````````````````````````````
179	M````````````````````````````````````````````````````````````
180	M````````````````````````````````````````````````````````````
181	M````````````````````````````````````````````````````````````
182	M````````````````````````````````````````````````````````````
183	M````````````````````````````````````````````````````````````
184	M````````````````````````````````````````````````````````````
185	M````````````````````````````````````````````````````````````
186	M````````````````````````````````````````````````````````````
187	M````````````````````````````````````````````````````````````
188	M````````````````````````````````````````````````````````````
189	M````````````````````````````````````````````````````````````
190	M````````````````````````````````````````````````````````````
191	M````````````````````````````````````````````````````````````
192	M````````````````````````````````````````````````````````````
193	M````````````````````````````````````````````````````````````
194	M````````````````````````````````````````````````````````````
195	M````````````````````````````````````````````````````````````
196	M````````````````````````````````````````````````````````````
197	M````````````````````````````````````````````````````````````
198	M````````````````````````````````````````````````````````````
199	M````````````````````````````````````````````````````````````
200	M````````````````````````````````````````````````````````````
201	M````````````````````````````````````````````````````````````
202	M````````````````````````````````````````````````````````````
203	M````````````````````````````````````````````````````````````
204	M````````````````````````````````````````````````````````````
205	M````````````````````````````````````````````````````````````
206	M````````````````````````````````````````````````````````````
207	M````````````````````````````````````````````````````````````
208	M````````````````````````````````````````````````````````````
209	M````````````````````````````````````````````````````````````
210	M````````````````````````````````````````````````````````````
211	M````````````````````````````````````````````````````````````
212	M````````````````````````````````````````````````````````````
213	M````````````````````````````````````````````````````````````
214	M````````````````````````````````````````````````````````````
215	M````````````````````````````````````````````````````````````
216	M````````````````````````````````````````````````````````````
217	M````````````````````````````````````````````````````````````
218	M````````````````````````````````````````````````````````````
219	M````````````````````````````````````````````````````````````
220	M````````````````````````````````````````````````````````````
221	M````````````````````````````````````````````````````````````
222	M````````````````````````````````````````````````````````````
223	M````````````````````````````````````````````````````````````
224	M````````````````````````````````````````````````````````````
225	M````````````````````````````````````````````````````````````
226	M````````````````````````````````````````````````````````````
227	M````````````````````````````````````````````````````````````
228	M````````````````````````````````````````````````````````````
229	M````````````````````````````````````````````````````````````
230	M````````````````````````````````````````````````````````````
231	M````````````````````````````````````````````````````````````
232	M````````````````````````````````````````````````````````````
233	M````````````````````````````````````````````````````````````
234	M````````````````````````````````````````````````````````````
235	M````````````````````````````````````````````````````````````
236	M````````````````````````````````````````````````````````````
237	M````````````````````````````````````````````````````````````
238	M````````````````````````````````````````````````````````````
239	M````````````````````````````````````````````````````````````
240	M````````````````````````````````````````````````````````````
241	M````````````````````````````````````````````````````````````
242	"````
243	`
244	end

Added Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_iso_3.iso.Z.uu (+40 lines)
1	Same as test_read_format_iso_2.iso.Z except that the root directory record
2	size in the PVD has been changed to 68 bytes (instead of the 34 required
3	by the standard). This non-standard value was seen in the wild.
4
5	begin 644 test_read_format_iso_3.iso.Z
6	M'YV0``('$BPH,&#"!,J7,BPH<.'$"-G$BQHL6+&#-JW,BQH\>/($.*'$FR
7	MI,F3%.J7,FRI<N7,&/G$FSILV;.'/JW,FSI\^?0(,*'4JTJ-&C2),J7<JT
8	MJ=.G4-G4JUJM6K6+-JW<JUJ]>O8,.'4NVK-FS:-.J7<NVK=NW<./G4NW
9	MKMV[>//JW<NWK]^_@`,+'DRXL.'#B!,K7LRXL>/'D"-+GDRYLN7+F#-KWLRY
10	ML^?/H$.+'DVZM.G3J%.K7LVZM>O7L&/+GDV[MNW;N'/KWLV[M^_?P(,+'TZ\
11	MN/'CR),K7\Z\N?/GT*-+GTZ]NO7KV+-KW\Z]N_?OX,.+'T^^O/GSZ-.K7\^^
12	MO?OW\./+GT^_OOW[^//KW\^_O_^_`0Q!!`PPQ!```$Z408<04Q`!PH,01BCA
13	MA!16:.&%$!Z404$;>G0@``%\>"`""`#@04$>2)#0!`,1`0`%!<%8HD`EEF+C
14	MC:4($)"(!V+HXX]`!BGDD$06:>212":IY)),-NGDDU!&*>645%9II8\R%!@#
15	M##C$0(,,,6Q)PPP$DI-EF%QZ"::89,)`#H%PQBDGG&=NV>67:(Y9YH?_]>GG
16	MGX7](R"!!@)JZ*&()JKHHL<="...`AU80:0`!`$B`!=0.@2CG';JZ:>@A@H8
17	MGR]>:FI`DP9@:F9!BCJJ[#&NNLM#XE0JD$R3A0C3C:J*.I(0)PZZ,#Z4HC
18	M`+WZ"BF((=XZ4&3SAA0B6\@X$`%"AA`SJ\\!G%KI@1EBT`U%J+[0+;+AOB
19	MIK6VZ^Z[\,8;G;,%1;LK`-5>FVVZP!XX;(SDWIMLCNJ&:`(`%A1D@0$%&9`O
20	MMMI2"B(!0KBP0PSR9JSQQAQWW!P:9;#!QAL>&SRR2BGK'GWQ8D[KT/*X`N
21	MMSOZBVNQ`1\[,,W,!G`P!@5AP#!!#ILK,SD2!T``$19CO/+34$<M]=2$@2PR
22	MR51GK?767'?M]==@ARWVV&27;?;9:*>M]MILM^WVVW#'+??<=-=M]]UXYZWW
23	MWGSW[???@`<N^."$%V[XX8@GKOCBC#?N^..01R[YY)17;OGEF&>N^>:<=^[Y
24	MYZ"'+OKHI)=N^NFHIZ[ZZJRW[OKKL,<N^^RTUV[[[;CGKOONO/?N^^_`!R_\
25	M\,07;_SQR">O_/+,-^_\\]!'+_WTU%=O_?789Z_]]MQW[_WWX(<O_OCDEV_^
26	M^>BGK_[Z[+?O_OOPQR___/37;__]^.>O__[\]^___P`,H``'2,`"&O"`"$R@
27	M`A?(P`8Z\($0C`$)TC!"EKP@AC,H`8WR,$.>O"#(`RA"$=(PA:\(0H3$
28	M5\C"%KKPA3",H0QG2,,:VO"&.,RA#G?(PQ[Z\(=`#(0ATC$(AKQB$A,HA7
29	MR,0F.O&)4(RB%=(Q2I:\8I8S(6M\C%+GKQBV`,HQC'2,8RFO&,:$RC&M?(
30	MQC:Z\8UPC,<YTC'.MKQCGC,HQ[WR,<^^O&/@`RD(`=)R$(:\I"(30B%\G(
31	M1CKRD9",I"0G2<E6O2F,RD)C?)R4YZ\I.@#4H1TG4IKRE*A,I2I7R<I6
32	MNO5L(RE+&=)RUK:\I:XS4N=\G+7OKRE\`,IC"'2<QB&O.8R$RF,I?)S&8Z
33	M\YG0C8TITG-:EKSFMC,IC:WR<UN>O.;X`RG.,=)SG:\YSH3*<ZU\G.=KKS
34	MG?",ISSG2<]ZVO.>^,RG/O?)SW[Z\Y\`#:A`!TK0@AKTH`A-J$(7RM"&.O2A
35	M$(VH1"=T8I:](8S:A&-\K1CGKTHR`-J4A'2M2FO2D$VI2E?TI:Z]4P
36	MC:E,9TK3FMKTICC-J4YWRM.>^O2G0`VJ4(=U(:]:A(3:I2E\K4ICKUJ5"-
37	MJE2G2M6J6O6J6,VJ5K?*U:YZ]:M@#:M8QTK6LIKUK&A-JUK7RM:VNO6M<(VK
38	".`$`
39	`
40	end




	    archive_read_support_format_all(a));
	assertEqualIntA(a, ARCHIVE_OK,
	    archive_read_open_filename(a, name, 512));

	/* Root directory */
	assertEqualIntA(a, ARCHIVE_OK,
	    archive_read_next_header(a, &ae));
	assertEqualIntA(a, 1131434684, archive_entry_atime(ae));
	assertEqualIntA(a, 0, archive_entry_birthtime(ae));
	assertEqualIntA(a, 1131434684, archive_entry_ctime(ae));
	assertEqualIntA(a, 0, archive_entry_dev(ae));
	assertEqualIntA(a, AE_IFDIR, archive_entry_filetype(ae));
	assertEqualIntA(a, 0, archive_entry_gid(ae));
	assertEqualStringA(a, NULL, archive_entry_gname(ae));
	assertEqualIntA(a, 0, archive_entry_ino(ae));
	assertEqualIntA(a, AE_IFDIR | 0700, archive_entry_mode(ae));
	assertEqualIntA(a, 1131434684, archive_entry_mtime(ae));
	assertEqualIntA(a, 2, archive_entry_nlink(ae));
	assertEqualStringA(a, ".", archive_entry_pathname(ae));
	assertEqualIntA(a, 0700, archive_entry_perm(ae));
	assertEqualIntA(a, 2048, archive_entry_size(ae));
	assertEqualIntA(a, 0, archive_entry_uid(ae));
	assertEqualStringA(a, NULL, archive_entry_uname(ae));

	assertEqualIntA(a, ARCHIVE_EOF,
	    archive_read_next_header(a, &ae));
	assertEqualInt(1, archive_file_count(a));
	assertEqualInt(archive_filter_code(a, 0),
	    ARCHIVE_FILTER_COMPRESS);

}

static void
test_small(const char *name)
{
	struct archive_entry *ae;
	struct archive *a;
	const char *name = "test_read_format_iso_2.iso.Z";

	extract_reference_file(name);


	    archive_read_support_format_all(a));
	assertEqualIntA(a, ARCHIVE_OK,
	    archive_read_open_filename(a, name, 512));

	/* Root directory */
	assertEqualIntA(a, ARCHIVE_OK,
	    archive_read_next_header(a, &ae));
	assertEqualString(".", archive_entry_pathname(ae));
	assertEqualInt(0, archive_entry_atime_is_set(ae));
	assertEqualInt(0, archive_entry_atime(ae));
	assertEqualInt(0, archive_entry_birthtime_is_set(ae));
	assertEqualInt(0, archive_entry_birthtime(ae));
	assertEqualInt(0, archive_entry_ctime_is_set(ae));
	assertEqualInt(0, archive_entry_ctime(ae));
	assertEqualIntA(a, 0, archive_entry_dev(ae));
	assertEqualIntA(a, AE_IFDIR, archive_entry_filetype(ae));
	assertEqualIntA(a, 0, archive_entry_gid(ae));
	assertEqualStringA(a, NULL, archive_entry_gname(ae));
	assertEqualIntA(a, 0, archive_entry_ino(ae));
	assertEqualIntA(a, AE_IFDIR | 0700, archive_entry_mode(ae));
	assertEqualInt(0, archive_entry_mtime_is_set(ae));
	assertEqualInt(0, archive_entry_mtime(ae));
	assertEqualIntA(a, 4, archive_entry_nlink(ae));
	assertEqualIntA(a, 0700, archive_entry_perm(ae));
	assertEqualIntA(a, 2048, archive_entry_size(ae));
	assertEqualIntA(a, 0, archive_entry_uid(ae));
	assertEqualStringA(a, NULL, archive_entry_uname(ae));

	/* Directory "A" */
	assertEqualIntA(a, ARCHIVE_OK,
	    archive_read_next_header(a, &ae));
	assertEqualString("A", archive_entry_pathname(ae));
	assertEqualIntA(a, 1313381406, archive_entry_atime(ae));
	assertEqualIntA(a, 0, archive_entry_birthtime(ae));
	assertEqualIntA(a, 1313381406, archive_entry_ctime(ae));
	assertEqualIntA(a, 0, archive_entry_dev(ae));
	assertEqualIntA(a, AE_IFDIR, archive_entry_filetype(ae));
	assertEqualIntA(a, 0, archive_entry_gid(ae));
	assertEqualStringA(a, NULL, archive_entry_gname(ae));
	assertEqualIntA(a, 0, archive_entry_ino(ae));
	assertEqualIntA(a, AE_IFDIR | 0700, archive_entry_mode(ae));
	assertEqualIntA(a, 1313381406, archive_entry_mtime(ae));
	assertEqualIntA(a, 2, archive_entry_nlink(ae));
	assertEqualIntA(a, 0700, archive_entry_perm(ae));
	assertEqualIntA(a, 2048, archive_entry_size(ae));
	assertEqualIntA(a, 0, archive_entry_uid(ae));
	assertEqualStringA(a, NULL, archive_entry_uname(ae));

	/* File "A/B" */
	assertEqualIntA(a, ARCHIVE_OK,
	    archive_read_next_header(a, &ae));
	assertEqualString("A/B", archive_entry_pathname(ae));
	assertEqualIntA(a, 1313381406, archive_entry_atime(ae));
	assertEqualIntA(a, 0, archive_entry_birthtime(ae));
	assertEqualIntA(a, 1313381406, archive_entry_ctime(ae));
	assertEqualIntA(a, 0, archive_entry_dev(ae));
	assertEqualIntA(a, AE_IFREG, archive_entry_filetype(ae));
	assertEqualIntA(a, 0, archive_entry_gid(ae));
	assertEqualStringA(a, NULL, archive_entry_gname(ae));
	assertEqualIntA(a, 0, archive_entry_ino(ae));
	assertEqualIntA(a, AE_IFREG | 0400, archive_entry_mode(ae));
	assertEqualIntA(a, 1313381406, archive_entry_mtime(ae));
	assertEqualIntA(a, 1, archive_entry_nlink(ae));
	assertEqualIntA(a, 0400, archive_entry_perm(ae));
	assertEqualIntA(a, 6, archive_entry_size(ae));
	assertEqualIntA(a, 0, archive_entry_uid(ae));
	assertEqualStringA(a, NULL, archive_entry_uname(ae));
	/* TODO: Verify that file contents are "hello\n" */

	/* Directory "C" */
	assertEqualIntA(a, ARCHIVE_OK,
	    archive_read_next_header(a, &ae));
	assertEqualString("C", archive_entry_pathname(ae));
	assertEqualIntA(a, 1313381411, archive_entry_atime(ae));
	assertEqualIntA(a, 0, archive_entry_birthtime(ae));
	assertEqualIntA(a, 1313381411, archive_entry_ctime(ae));
	assertEqualIntA(a, 0, archive_entry_dev(ae));
	assertEqualIntA(a, AE_IFDIR, archive_entry_filetype(ae));
	assertEqualIntA(a, 0, archive_entry_gid(ae));
	assertEqualStringA(a, NULL, archive_entry_gname(ae));
	assertEqualIntA(a, 0, archive_entry_ino(ae));
	assertEqualIntA(a, AE_IFDIR | 0700, archive_entry_mode(ae));
	assertEqualIntA(a, 1313381411, archive_entry_mtime(ae));
	assertEqualIntA(a, 2, archive_entry_nlink(ae));
	assertEqualIntA(a, 0700, archive_entry_perm(ae));
	assertEqualIntA(a, 2048, archive_entry_size(ae));
	assertEqualIntA(a, 0, archive_entry_uid(ae));
	assertEqualStringA(a, NULL, archive_entry_uname(ae));

	/* File "C/D" */
	assertEqualIntA(a, ARCHIVE_OK,
	    archive_read_next_header(a, &ae));
	assertEqualString("C/D", archive_entry_pathname(ae));
	assertEqualIntA(a, 1313381411, archive_entry_atime(ae));
	assertEqualIntA(a, 0, archive_entry_birthtime(ae));
	assertEqualIntA(a, 1313381411, archive_entry_ctime(ae));
	assertEqualIntA(a, 0, archive_entry_dev(ae));
	assertEqualIntA(a, AE_IFREG, archive_entry_filetype(ae));
	assertEqualIntA(a, 0, archive_entry_gid(ae));
	assertEqualStringA(a, NULL, archive_entry_gname(ae));
	assertEqualIntA(a, 0, archive_entry_ino(ae));
	assertEqualIntA(a, AE_IFREG | 0400, archive_entry_mode(ae));
	assertEqualIntA(a, 1313381411, archive_entry_mtime(ae));
	assertEqualIntA(a, 1, archive_entry_nlink(ae));
	assertEqualIntA(a, 0400, archive_entry_perm(ae));
	assertEqualIntA(a, 6, archive_entry_size(ae));
	assertEqualIntA(a, 0, archive_entry_uid(ae));
	assertEqualStringA(a, NULL, archive_entry_uname(ae));
	/* TODO: Verify that file contents are "hello\n" */

	/* Final statistics */
	assertEqualIntA(a, ARCHIVE_EOF,
	    archive_read_next_header(a, &ae));
	assertEqualInt(5, archive_file_count(a));

DEFINE_TEST(test_read_format_iso_Z)
{
	test1();
	/* A very small ISO image with a variety of contents. */
	test_small("test_read_format_iso_2.iso.Z");
	/* As above, but with a non-standard 68-byte root directory in the PVD */
	test_small("test_read_format_iso_3.iso.Z");
}

Lines 158-164 test_read_format_mtree1(void) Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_mtree.c (-1 / +1 lines)
158	/* TODO: Mtree reader should probably return ARCHIVE_WARN for this. */	158	/* TODO: Mtree reader should probably return ARCHIVE_WARN for this. */
159	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));	159	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
160	assertEqualString(archive_entry_pathname(ae), "dir2/toosmallfile");	160	assertEqualString(archive_entry_pathname(ae), "dir2/toosmallfile");
161	assertEqualInt(archive_entry_size(ae), -1);	161	assertEqualInt(archive_entry_size(ae), 0);
162	assertEqualInt(archive_entry_is_encrypted(ae), 0);	162	assertEqualInt(archive_entry_is_encrypted(ae), 0);
163	assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);	163	assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
164		164

Added Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_rar4_encrypted.rar.uu (+10 lines)
1	begin 0744 test_read_format_rar4_encrypted.rar
2	M4F%R(1H'`,^0<P``#0`````````J8W0@D"H`$@```!(````"56Y:[F17=E@=
3	M,`4`(````&$N='AT`/#\3!M4:&ES(&ES(&9R;VT@82YT>'1?CG0DE#(`(```
4	M`!(````"A13ZJ6=7=E@=,P4`(````&(N='ATO@(;FGDJBE4`L'*@-,GY]@T0
5	M?ZC1UGSKU*2VR-1K@HH>GZZP#?C:ML=$"NKDN\=T()`J`!(````2`````C4]
6	MFI1N5W98'3`%`"````!C+G1X=`"P/D@M5&AI<R!I<R!F<F]M(&,N='AT[<IT
7	M))0R`"`````2`````B7ANB9-9'98'3,%`"````!D+G1X=*_B?1/SI5-2`/#[
8	I88]V^#_)1V@;4"TVC,!XR=.I1:KVB0/<OAC@C&97VP3UZ<0]>P!`!P``
9	`
10	end

Added Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_rar4_encrypted_filenames.rar.uu (+14 lines)
1	begin 0744 test_read_format_rar4_encrypted_filenames.rar
2	M4F%R(1H'`,Z9<X``#0```````````````````'0+AC,H,+6'0#)>8VT<XO:*
3	M5M'"E1[V+ZKT=VW!$Y2=W$,@Y24Z^"L_;GVG\*4]&"6BQ#?@6TX38EQ\8\4-
4	M<S5U7JMAF.'L3LOOCM6]\Q60C51S.)^'6MOG_R<DW8EG(```````````(B,(
5	M]O5[61NCM'\Q9[&<E5D6F6`?WI`#-.(]J?W^C9!U-5O^2='P+5K(ED[:I4T=
6	M0/ZHVQ[F8HPBZ<+WA.*T5<R$K+8&/OR_\BN8V5VVM]"5F:$4Y:\JR,),%],1
7	MR;Z>``````````#B0$)1EIB[[O98],X0DT>H`N+&.NNPK!]1XJ#(AF_TF6
8	M0FE3!L0.1T+=I<'X[Z0:F23U_[6S.I:ZNQ.\@HZ\]&0L/P:SA$:,Y<^4.A!\
9	MSBD7NK5[VE/9$9K/N2`[7]T``````````.\$Z3?>_Z.3*>6<12%741?6_./A
10	M!:XA!P"B0PS55>+%J)-H$0T!//>$']'-U?_"O=N?_:SNE<^54Z3/[8,M^F?6
11	M36)XOUNLS4@\\N@1J#Z/V?J<_XS>CNA21,<Q;<;C[@``````````\)]%=^L\
12	*)-I(DJO^>177HP``
13	`
14	end

Added Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_rar4_solid_encrypted.rar.uu (+11 lines)
1	begin 0744 test_read_format_rar4_solid_encrypted.dat
2	M4F%R(1H'`#O0<P@`#0`````````A873$E#(`,````!(````"56Y:[F17=E@=
3	M,P4`(````&$N='AT````````````\/Q,&]Q,RV`3V)H10_&#G@'FZ'@$+I%W
4	MXP?A#XMQ>A-D/\9QH!R+,]AV(8FMQD3.<V`SC96=-24,@`0````$@````%
5	M%/JI9U=V6!TS!0`@````8BYT>'2/%M7(05"L]0"P<J`TBK7M!JH)_:_8K\\K
6	M,U_X>\,C=-24,@`0````$@````(U/9J4;E=V6!TS!0`@````8RYT>'1ILB:<
7	M@2)@M@"P/D@MD'UA]R2N^_G@1!L-H?V>K-TV=-24,@`0````$@````(EX;HF
8	M361V6!TS!0`@````9"YT>'2C+AKDKML%S0#P^V&/?J,L#@>!52=M.=PPCAJF
9	(IL0]>P!`!P``
10	`
11	end

Added Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_rar4_solid_encrypted_filenames.rar.uu (+13 lines)
1	begin 0744 test_read_format_rar4_solid_encrypted_filenames.rar
2	M4F%R(1H'`#K9<X@`#0```````````````````,L":IWIGA+/YV2@]#O3Z\&O
3	MM'G1)=DT/G2[DW184@7Z`)NZR=<IA_-5+=&`P_B)U/,]<+8]C:YI<X@;OT`3
4	M]?.U#K0BV:I"0AYHE-->?V[74Q\@?])NR\68105J4BRL3O.E$I*!91X?$@/<
5	M5C[G2D$``````````!NS=YISD[7`_=#)$A.9/&9<3`&D$(L]$^-&%;!SH,%>
6	M!NZ:W\)5XCJI<"H7+BND(033Q/J9/18(=/`A%WI]@(`:H>AE`M3T)R8']S%P
7	MHYCV```````````&TB\_##3K6#@Q+J)RDEJ0$CI"]*R1)8!Q.3B[,7O5NM,]
8	ME::7;E__N2:-%4-;/D+DA:J@P.L0I/__OX77=\L4-&F^""&L'VP9/DK-;$
9	MLP``````````1D.3Y0+"D$@9F(IYV&B<`A2J2$)(C=_X_QEMWEVK9ITH*U
10	MAJ@<<Z%4#?(I"H:5J08&7^WM`<#3=A9D#':;X2IVK.%[ZZ#58(4W0Q[RT-X`
11	7`````````/"?17?K/"3:2)*K_GD5UZ,`
12	`
13	end




	struct archive_entry *ae;
	struct archive *a;
	uint8_t buf[173];
	ssize_t bytes_read;
	uint32_t computed_crc = 0;

	extract_reference_file("test_read_format_rar5_compressed.rar");

	assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
	assertEqualString("file.txt", archive_entry_symlink(ae));
	assertEqualInt(AE_SYMLINK_TYPE_FILE, archive_entry_symlink_type(ae));
	assertEqualInt(0, archive_entry_size(ae));
	assertA(0 == archive_read_data(a, NULL, (size_t)archive_entry_size(ae)));

	assertA(0 == archive_read_next_header(a, &ae));
	assertEqualString("dirlink", archive_entry_pathname(ae));
	assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
	assertEqualString("dir", archive_entry_symlink(ae));
	assertEqualInt(AE_SYMLINK_TYPE_DIRECTORY, archive_entry_symlink_type(ae));
	assertEqualInt(0, archive_entry_size(ae));
	assertA(0 == archive_read_data(a, NULL, (size_t)archive_entry_size(ae)));

	assertA(0 == archive_read_next_header(a, &ae));
	assertEqualString("dir", archive_entry_pathname(ae));
	assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
	assertEqualInt(0, archive_entry_size(ae));
	assertA(0 == archive_read_data(a, NULL, (size_t)archive_entry_size(ae)));

	assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));


	assertEqualString("hardlink.txt", archive_entry_pathname(ae));
	assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
	assertEqualString("file.txt", archive_entry_hardlink(ae));
	assertEqualInt(0, archive_entry_size(ae));
	assertA(0 == archive_read_data(a, NULL, (size_t)archive_entry_size(ae)));

	assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));



	assertA(size == archive_read_data(a, buff, size));
	assertEqualMem(buff, test_txt, size);

	EPILOGUE();
}



	EPILOGUE();
}

DEFINE_TEST(test_read_format_rar5_data_ready_pointer_leak)
{
	/* oss fuzz 70024 */

	char buf[4096];
	PROLOGUE("test_read_format_rar5_data_ready_pointer_leak.rar");

	/* Return codes of those calls are ignored, because this sample file
	 * is invalid. However, the unpacker shouldn't produce any SIGSEGV
	 * errors during processing. */

	(void) archive_read_next_header(a, &ae);
	(void) archive_read_data(a, buf, sizeof(buf));
	(void) archive_read_next_header(a, &ae);
	(void) archive_read_data(a, buf, sizeof(buf));
	(void) archive_read_data(a, buf, sizeof(buf));
	(void) archive_read_next_header(a, &ae);
	/* This call shouldn't produce SIGSEGV. */
	(void) archive_read_data(a, buf, sizeof(buf));

	EPILOGUE();
}

Added Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_rar5_data_ready_pointer_leak.rar.uu (+28 lines)
1	begin 644 test_read_format_rar5_data_ready_pointer_leak.rar.uu
2	M4F%R(1H'`0`]/-[E`@$`_R`@1#[Z5P("`P,`(/__(""`((``"2`@("`@_R`@
3	M("`@(%.`*O0#`N<B`A"`("#_((`+`00@("`@(""!)/\@("`@("`@(/\@("`@
4	M^I@R<00"WN<-\@$@_R`@(``C("`@("`@("`@("`@("`@("`@("`@("`@("#_
5	M____("`@(/___R#_("`@("`@("#___\@_____R`@("`@("`@(/__________
6	M____(/__(/\@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@________
7	M_________R`@____(/____\@("`@("`@("#______________R#___\@("`@
8	M("`@("`@("`@("`@("`@("`@(/\@("`@("`@("`@("`@("`@("`@("`@("`@
9	M("`@("`@("`@("`@("`@("`@("`@("`@_________R`@("`@_R`@("`@("`@
10	M("`@("`@(/__("`@("`@("`@("`@("`@(%.`*O0#`N<B`A"`_R`@_R#_"P$$
11	M("`@("`@@23_("`@_R`@("#_("`@(/J8,G$$`M[G#?(!(/\@("``(R`@("`@
12	M("`@("`@("`@("`@("`@("`@("#_("`@("`@("#_("`@("`@("`@("`@("`@
13	M("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("#_
14	M("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@____("`@("`@
15	M("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@
16	M("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@
17	M("`@("`@("`@("`@("`@("`@_R`@("`@("`@("`@("`@("`@("`@("`@("`@
18	M("!3@"KT`P+G(B`0@/\@(/\@_PL!_R"!)/\@("`@("`@(/\@("`@^I@R<00"
19	MWN<-\@$@_R`@(``C("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@
20	M("`@("#______________R`@("`@("`@("`@("`@("`@("`@("`@("`@("`@
21	M("`@("`@("`@("`@("`@("`@("`@(/\@(/_______R`@("`@("`@("`@("`@
22	M("`@("`@("`@_________R`@("`@("`@("`@("`@("`@(/________\@("`@
23	M("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@(/\@
24	M("`@("`@(/\@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@
25	M("`@("`@("`@("`@("`@(/\@($0^^E<"`@,#("`@(/\@@``)("`@("`@("`@
26	)("`@("`@("`@
27	`
28	end

Added Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_rar5_encrypted.rar.uu (+12 lines)
1	begin 0744 test_read_format_rar5_encrypted.rar
2	M4F%R(1H'`0`SDK7E"@$%!@`%`0&`@``U_S(>'P(#"Q($$B!5;EKN@```!6$N
3	M='AT"@,"?"&$HX)\V@%4:&ES(&ES(&9R;VT@82YT>'1Z07&S4`(#/#`$$B`8
4	M1:,"@`,`!6(N='AT,`$``P_'1%[A@/BUG]8K0S<(O%?-^C3?!JM=!=23!W</
5	M'8Z`4^HU9QUP\2U+:YP:G`H#`G)EF*:"?-H!8[I4LM`0I4E?M+K3P&FH.QN\
6	MNS@GUX>3>',O?)/BTBC$`-[^IL`[?FQGU`50`-SXC7SQ9A\"`PL2!!(@-3V:
7	ME(````5C+G1X=`H#`CY(Z:Z"?-H!5&AI<R!I<R!F<F]M(&,N='AT[/WP75("
8	M`SR@``22`"##WV,2@`,`!60N='AT,`$``P_'1%[A@/BUG]8K0S<(O%?-\\W6
9	MLQRT6Z=\K#98CK,.:8-,U$CI%>O6K'>WHPH#`GO%*?2/?-H!VVER]/96CJ;]
10	?&67IE;,VA30W]2J@TR>'LO7!`C+8JEX==U91`P4$````
11	`
12	end

Added Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_rar5_encrypted_filenames.rar.uu (+19 lines)
1	begin 0744 test_read_format_rar5_encrypted_filenames.rar
2	M4F%R(1H'`0"N(]0(00```$/:`NPT?(O:'>==Q,C2;&;<@A@[)[D`X\II
3	M)1#LA,>A'D8M?0XU3L36UDKMZ3EWQ[HCXZ3<%!O=.Y,W/S<QCA?O/:,^Z5
4	M=M6S3Y6;+35C`9`4W]<':72F3'&:K>,FBUJV)T^1MW,X0)C4P7W(`"$#-N
5	MQ\V%/Z&YJ=4A7#WA+9.5'__1CF)4F:?SV[[N1U^16P.+TQ5X.'"@NQ"=6K3Z
6	M>:;.1CVE<%%M1-OQ3L0FZ[KI2TSW`.2SF20<ZT/,=/(WK4+9"\+J&$')_3V,
7	MFW%?=^[MI.6[JA/>0V5WTB3-QIV<3Q'?++X$0]?XV(?ER,71CAXBNL1KT5A*
8	M8&+T@6]A_)KA]%V3S,0B;S(LW1V.AH.U6U0N\-%!@J9Q-FJ%^'O)(JR5+2
9	MS$5JO/XA3W4MSJ[R27%P_4$GAWSW!SS(4IA_-)Z:[:?V5D!F@TGG9L0!1TF[
10	M:AH<9G0.['%7-\:>"&(8Y#Z#62;U.:,3+=<$E6S8C02I[/<OZ>G>-3P1Y<'J
11	MW_FJ/]VJ-Q7IA64<?`;GTW<H]@=YS0)S*\?SKXQ$H.Y!<ZK`[1[?Z(\(_\]>
12	MU:_TK/EHMM;PWJ?3`Y9S6&%6L@T0-U<&4E[+_F>Z%+KFW'&W>`,.=]#SI;A[
13	MYA);NM6`5K01J]@IT6O8W#!].A$%_5M\E]S0&<D`"T,:H7>.TOPBCL9$C"GU
14	M2<W)Q\9ABJLH57<$#;&%<^N#-N[5KE?`56,WSHG<GU4!!.+@ZU+5N\;J[7J-
15	M**R#V\19<I;O[I%?-002U,8R$.^M/P8W]?26N+VB5-\B#7;SV;_L#%4PQ36P
16	MBTTF>G&8E))@.H01Q:@1Q^.YVYIG(?#2:S604D\'CWU.!:-E`=;4VFS+KULL
17	KJ<2G@G$-MF5V72TYY!]U(UB473O?`U'=W'#D\4A%S-_F?/@]S)MU>.[V1```
18	`
19	end

Added Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_rar5_solid_encrypted.rar.uu (+14 lines)
1	begin 0744 test_read_format_rar5_solid_encrypted.rar
2	M4F%R(1H'`0`@MOH1"@$%!@0%`0&`@`!A#\6>4@(#/+``!)(`(%5N6NZ`0P`%
3	M82YT>'0P`0`!#X`.^EM!19`,=C!0B-G+#?0([51UI],+OH^T\:=V\5`OX@\X
4	M+B?>=W@0'[TD"@,"?"&$HX)\V@$UI92M^>J?V-L?2@`2L023@_#?H\C>K?GG
5	MDT*27O`>\]$\(4^12SZAD2GI6I(?@NS\ETUG4@(#/)``!)(`(#W[M6/`0P`%
6	M8BYT>'0P`0`##X`.^EM!19`,=C!0B-G+#?09'G;UMT5!4+;8`6WM=*[?X@\X
7	M+B?>=W@0'[TD"@,"<F68IH)\V@$C,XZR45`RX*-59&X3Y'+)'7P<"E("`SR0
8	M``22`"#_)YR&P$,`!6,N='AT,`$``P^`#OI;0460#'8P4(C9RPWT6V3<1-F,
9	M1I0"0-:R/5=BUN(/."XGWG=X$!^])`H#`CY(Z:Z"?-H!BBA?J'.;?7%L12A&
10	M0%6=`D>/[#]2`@,\D``$D@`@>Q=TP\!#``5D+G1X=#`!``,/@`[Z6T%%D`QV
11	M,%"(V<L-]&ES:(+U/SMVI#;?U9:@A&OB#S@N)]YW>!`?O20*`P)[Q2GTCWS:
12	9`3G@<$3$LKSYCC7DX.K9`[`==U91`P4$````
13	`
14	end

Added Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_rar5_solid_encrypted_filenames.rar.uu (+18 lines)
1	begin 0744 test_read_format_rar5_solid_encrypted_filenames.rar
2	M4F%R(1H'`0";0=T:(00```$/AC5`PSS2$L"IUF$&I":C])K[3<7Y3A09X<`H
3	M`7''7U?%(MHPZ3W;#Z7PZEC<2`T4N9L0A@JE?=;1"4#J%N#6H+4KYITU<*=Q
4	MG$W?R7^W[#&LN^@M8(VSG.,@!1JFX359D^5#S[,ZW]V]CJ'J?-Z!KX^]Y1FB
5	M8I%5/(^2-8V^KY:K1^?K`DVW*MUL>Q9_6`W#,2ST:17"'W'YF2?)NH%5V"_F
6	M7;[0VI^.\JJ-T,_(\\5#ZX1HVQJ7KU0UCF#FGD-?NRMKA;X<,[/[*94^27X,
7	M#)I<:BO^_-I%B&A1U>S)9__""\/M>Q5AIY'*]EPTNJW+.J57[$X\U:;W">Z;
8	M8P\Z0[ZQOIB?BJ?B5+(/Z4.4AJ@;()1YUV4+XY#!76WZV]LZ+;GZ_Q#LLP
9	MP`7??+NV**I(A-9N^7HX\V!+YJ3%;R<PA5#T<.1"/TKRXC6SM=>%MD?Q5&H@
10	M>$VAME3"U$312+@SF+8F2RR0)T"DG^4N,^P46&+TZKQ7KS`4@-:J%_["UP"(
11	MK=]N^!UJUO2#6Q*`-`-)^?\/`;^4(@FVLVJ?!D,:O)A6@!TNA%.U^"0-?9H<
12	M:0&(UWV=+&[82L>'L4XYO20"@)^<WC4/BKMBFP0G&/3,![Y+,F),X7V7]H
13	M3&`4SIL,>I']_<2C]D;_,]/)_1?N1+M@PTDL;'[J1L=5\,-?J5Q`$3>_9<2<
14	MS^)#MZAE=5@5[O(<](EIA62$U`5B18?#W;BB.*0A3O%<OI.7X`?QB-FRV]
15	M898RNH'P\"9I,0X&F;$<0Z70E(,^KF&PZ5WR-O%K;G`"/=E<\4-H%FZ]O3
16	8G%A)/>[(IVC3ME2PY5F>9$/U'$VW1-BZ
17	`
18	end




/*
 * Copyright (c) 2003-2018
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"

/*
 * All of the archives for this teset contain four files: a.txt, b.txt, c.txt, and d.txt
 * For solid archives or archvies or archives where filenames are encrypted, all four files are encrypted with the
 * password "password". For non-solid archives without filename encryption, a.txt and c.txt are not encrypted, b.txt is
 * encrypted with the password "password", and d.txt is encrypted with the password "password2".
 *
 * For all files the file contents is "This is from <filename>" (i.e. "This is from a.txt" etc.)
 */
static void test_encrypted_rar_archive(const char *filename, int filenamesEncrypted, int solid)
{
	struct archive_entry *ae;
	struct archive *a;
	char buff[128];
	int expected_read_header_result, expected_read_data_result;
	const int expected_file_size = 18; /* This is from X.txt */

	/* We should only ever fail to read the header when filenames are encrypted. Otherwise we're failing for other
	 * unsupported reasons, in which case we have no hope of detecting encryption */
	expected_read_header_result = filenamesEncrypted ? ARCHIVE_FATAL : ARCHIVE_OK;

	/* We should only ever fail to read the data for "a.txt" and "c.txt" if they are encrypted */
	/* NOTE: We'll never attempt this when filenames are encrypted, so we only check for solid here */
	expected_read_data_result = solid ? ARCHIVE_FATAL : expected_file_size;

	extract_reference_file(filename);
	assert((a = archive_read_new()) != NULL);
	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
	assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, filename, 10240));

	/* No data read yet; encryption unknown */
	assertEqualInt(ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW, archive_read_has_encrypted_entries(a));

	/* Read the header for "a.txt" */
	assertEqualIntA(a, expected_read_header_result, archive_read_next_header(a, &ae));
	if (!filenamesEncrypted) {
		assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
		assertEqualString("a.txt", archive_entry_pathname(ae));
		assertEqualInt(expected_file_size, archive_entry_size(ae));
		assertEqualInt(solid, archive_entry_is_data_encrypted(ae));
		assertEqualInt(0, archive_entry_is_metadata_encrypted(ae));
		/* NOTE: The reader will set this value to zero on the first header that it reads, even if later entries
		 * are encrypted */
		assertEqualInt(solid, archive_read_has_encrypted_entries(a));
		assertEqualIntA(a, expected_read_data_result, archive_read_data(a, buff, sizeof(buff)));
		if (!solid) {
			assertEqualMem("This is from a.txt", buff, expected_file_size);
		}
	}
	else {
		assertEqualInt(1, archive_entry_is_data_encrypted(ae));
		assertEqualInt(1, archive_entry_is_metadata_encrypted(ae));
		assertEqualInt(1, archive_read_has_encrypted_entries(a));
		assertEqualInt(ARCHIVE_FATAL, archive_read_data(a, buff, sizeof(buff)));

		/* Additional attempts to read headers are futile */
		assertEqualInt(ARCHIVE_OK, archive_read_close(a));
		assertEqualInt(ARCHIVE_OK, archive_read_free(a));
		return;
	}

	/* From here on out, we can assume that !filenamesEncrypted */

	/* Read the header for "b.txt" */
	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
	assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
	assertEqualString("b.txt", archive_entry_pathname(ae));
	assertEqualInt(expected_file_size, archive_entry_size(ae));
	assertEqualInt(1, archive_entry_is_data_encrypted(ae));
	assertEqualInt(0, archive_entry_is_metadata_encrypted(ae));
	assertEqualInt(1, archive_read_has_encrypted_entries(a));
	assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buff, sizeof(buff)));

	/* Read the header for "c.txt" */
	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
	assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
	assertEqualString("c.txt", archive_entry_pathname(ae));
	assertEqualInt(expected_file_size, archive_entry_size(ae));
	assertEqualInt(solid, archive_entry_is_data_encrypted(ae));
	assertEqualInt(0, archive_entry_is_metadata_encrypted(ae));
	/* After setting to true above, this should forever be true */
	assertEqualInt(1, archive_read_has_encrypted_entries(a));
	assertEqualIntA(a, expected_read_data_result, archive_read_data(a, buff, sizeof(buff)));
	if (!solid) {
		assertEqualMem("This is from c.txt", buff, expected_file_size);
	}

	/* Read the header for "d.txt" */
	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
	assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
	assertEqualString("d.txt", archive_entry_pathname(ae));
	assertEqualInt(expected_file_size, archive_entry_size(ae));
	assertEqualInt(1, archive_entry_is_data_encrypted(ae));
	assertEqualInt(0, archive_entry_is_metadata_encrypted(ae));
	assertEqualInt(1, archive_read_has_encrypted_entries(a));
	assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buff, sizeof(buff)));

	/* End of archive. */
	assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));

	/* Close the archive. */
	assertEqualInt(ARCHIVE_OK, archive_read_close(a));
	assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}

DEFINE_TEST(test_read_format_rar4_encrypted)
{
	test_encrypted_rar_archive("test_read_format_rar4_encrypted.rar", 0, 0);
}

DEFINE_TEST(test_read_format_rar4_encrypted_filenames)
{
	test_encrypted_rar_archive("test_read_format_rar4_encrypted_filenames.rar", 1, 0);
}

DEFINE_TEST(test_read_format_rar4_solid_encrypted)
{
	/* TODO: If solid RAR4 support is ever added, the following should pass */
#if 0
	test_encrypted_rar_archive("test_read_format_rar4_solid_encrypted.rar", 0, 1);
#else
	skipping("RAR4 solid archive support not currently available");
#endif
}

DEFINE_TEST(test_read_format_rar4_solid_encrypted_filenames)
{
	test_encrypted_rar_archive("test_read_format_rar4_solid_encrypted_filenames.rar", 1, 1);
}

DEFINE_TEST(test_read_format_rar5_encrypted)
{
	test_encrypted_rar_archive("test_read_format_rar5_encrypted.rar", 0, 0);
}

DEFINE_TEST(test_read_format_rar5_encrypted_filenames)
{
	test_encrypted_rar_archive("test_read_format_rar5_encrypted_filenames.rar", 1, 0);
}

DEFINE_TEST(test_read_format_rar5_solid_encrypted)
{
	test_encrypted_rar_archive("test_read_format_rar5_solid_encrypted.rar", 0, 1);
}

DEFINE_TEST(test_read_format_rar5_solid_encrypted_filenames)
{
	test_encrypted_rar_archive("test_read_format_rar5_solid_encrypted_filenames.rar", 1, 1);
}

Lines 437-443 static void verify(unsigned char *d, size_t s, Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_tar.c (-1 / +1 lines)
437	assertA(0 == archive_read_support_filter_all(a));	437	assertA(0 == archive_read_support_filter_all(a));
438	assertA(0 == archive_read_support_format_all(a));	438	assertA(0 == archive_read_support_format_all(a));
439	assertA(0 == archive_read_open_memory(a, buff, s + 1024));	439	assertA(0 == archive_read_open_memory(a, buff, s + 1024));
440	assertA(0 == archive_read_next_header(a, &ae));	440	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
441	assertEqualInt(archive_filter_code(a, 0), compression);	441	assertEqualInt(archive_filter_code(a, 0), compression);
442	assertEqualInt(archive_format(a), format);	442	assertEqualInt(archive_format(a), format);
443	assertEqualInt(archive_entry_is_encrypted(ae), 0);	443	assertEqualInt(archive_entry_is_encrypted(ae), 0);




/*-
 * Copyright (c) 2003-2023 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"

/*
 * Read a pax formatted tar archive that has an extremely large
 * (8,000,000 bytes) attribute of unknown type.  The pax reader should simply
 * skip the attribute.
 */
DEFINE_TEST(test_read_format_tar_pax_large_attr)
{
	char name[] = "test_read_format_tar_pax_large_attr.tar.Z";
	struct archive_entry *ae;
	struct archive *a;

	assert((a = archive_read_new()) != NULL);
	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
	extract_reference_file(name);
	assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 10240));

	/* Read first entry. */
	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
	assertEqualString("foo", archive_entry_pathname(ae));
	assertEqualInt(1, archive_entry_mtime(ae));
	assertEqualInt(1000, archive_entry_uid(ae));
	assertEqualString("tim", archive_entry_uname(ae));
	assertEqualInt(0, archive_entry_gid(ae));
	assertEqualString("wheel", archive_entry_gname(ae));
	assertEqualInt(0100644, archive_entry_mode(ae));
	assertEqualInt(archive_entry_is_encrypted(ae), 0);
	assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);

	/* Verify the end-of-archive. */
	assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));

	/* Verify that the format detection worked. */
	assertEqualInt(archive_filter_code(a, 0), ARCHIVE_FILTER_COMPRESS);
	assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE);

	assertEqualInt(ARCHIVE_OK, archive_read_close(a));
	assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}

Added Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_tar_pax_large_attr.tar.Z.uu (+149 lines)
1	Decode this file with:
2	cat test_read_format_tar_pax_large_attr.tar.Z.uu \| uudecode -p \| uncompress \| hexdump -C
3
4	It contains a single tar entry with a pax header that has a single
5	attribute of 8000000 bytes
6	00000200 38 30 30 30 30 30 30 20 75 6e 6b 6e 6f 77 6e 3d \|8000000 unknown=\|
7	00000210 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b \|++++++++++++++++\|
8	*
9	007a13f0 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 0a \|+++++++++++++++.\|
10
11	begin 644 test_read_format_tar_pax_large_attr.tar.Z
12	M'YV04,+@05(F#)DR<EZ8>?,&@,.'$"-*G$BQHL6+&"O"V&B#!@T0`#;"N&&C
13	M!DB1,&1\#+EQ1L<8,42"B$&CA@P;-UQZM`$"1HP9-6+<```"3\:C2),J73JQ
14	MSAPZ8>2PI).F#5.+3\.8,7-U(LJ-)[^"[$JVK-FS:-'B^`H#1!TW:]R\N>.F
15	MQXJ[>//JW<NWK]^_@`,+'DRXL.'#B!,K7LRXL>/'D"-+GDRYLN7+F#-KWLRY
16	ML^?/H$.+'DVZM.G3J%.K7LVZM>O7L&/+GDV[MNW;N'/KWLV[M^_?P(,+'TZ\
17	MN/'CR),K7\Z\N?/GT*-+GTZ]NO7KV+-KW\Z]N_?OX,.+'T^^O/GSZ-.K7\^^
18	MO?OW\./+GT^_OOW[^//KW\^_O___``8HX(`$%FC@@0@FJ.""##;HX(,01BCA
19	MA!16:.&%&&:HX88<=NCAAR"&.())9HXHDHIJCBBBRVZ.*+,,8HXXPTUFCC
20	MC3CFJ...//;HXX]`!BGDD$06:>212":IY)),-NGDDU!&*>645%9IY9589JGE
21	MEEQVZ>678(8IYIADEFGFF6BFJ>::;+;IYIMPQBGGG'36:>>=>.:IYYY\]NGG
22	MGX`&NB@A!9JZ&()JKHHHPVZNBCD$8JZ:245FKII9AFJNFFG';JZ:>@ABKJ
23	MJ26:NJIJ:JZJJLMNKJJ[#&*NNLM-9JZZVXYJKKKKSVZNNOP`8K[+#$%FOL
24	ML<@FJ^RRS#;K[+/01BOMM-16:^VUV&:K[;;<=NOMM^"&*^ZXY)9K[KGHIJON
25	MNNRVZ^Z[\,8K[[STUFOOO?CFJ^^^_/;K[[\`!RSPP`07;/#!"">L\,(,-^SP
26	MPQ!'+/'$%%=L\<489ZSQQAQW[/''((<L\L@DEVSRR2BGK/+*++?L\LLPQRSS
27	MS#37;//-..>L\\X\]^SSST`'+?301!=M]-%()ZWTTDPW[?334$<M]=145VWU
28	MU5AGK?767'?M]==@ARWVV&27;?;9:*>M]MILM^WVVW#'+??<=-=M]]UXYZWW
29	MWGSW[???@`<N^."$%V[XX8@GKOCBC#?N^..01R[YY)17;OGEF&>N^>:<=^[Y
30	MYZ"'+OKHI)=N^NFHIZ[ZZJRW[OKKL,<N^^RTUV[[[;CGKOONO/?N^^_`!R_\
31	M\,07;_SQR">O_/+,-^_\\]!'+_WTU%=O_?789Z_]]MQW[_WWX(<O_OCDEV_^
32	M^>BGK_[Z[+?O_OOPQR___/37;__]^.>O__[\]^___P`,H``'2,`"&O"`"$R@
33	M`A?(P`8Z\($0C`$)TC!"EKP@AC,H`8WR,$.>O"#(`RA"$=(PA:\(0H3$
34	M5\C"%KKPA3",H0QG2,,:VO"&.,RA#G?(PQ[Z\(=`#(0ATC$(AKQB$A,HA7
35	MR,0F.O&)4(RB%=(Q2I:\8I8S(6M\C%+GKQBV`,HQC'2,8RFO&,:$RC&M?(
36	MQC:Z\8UPC,<YTC'.MKQCGC,HQ[WR,<^^O&/@`RD(`=)R$(:\I"(30B%\G(
37	M1CKRD9",I"0G2<E6O2F,RD)C?)R4YZ\I.@#4H1TG4IKRE*A,I2I7R<I6
38	MNO5L(RE+&=)RUK:\I:XS4N=\G+7OKRE\`,IC"'2<QB&O.8R$RF,I?)S&8Z
39	M\YG0C8TITG-:EKSFMC,IC:WR<UN>O.;X`RG.,=)SG:\YSH3*<ZU\G.=KKS
40	MG?",ISSG2<]ZVO.>^,RG/O?)SW[Z\Y\`#:A`!TK0@AKTH`A-J$(7RM"&.O2A
41	M$(VH1"=T8I:](8S:A&-\K1CGKTHR`-J4A'2M2FO2D$VI2E?TI:Z]4P
42	MC:E,9TK3FMKTICC-J4YWRM.>^O2G0`VJ4(=U(:]:A(3:I2E\K4ICKUJ5"-
43	MJE2G2M6J6O6J6,VJ5K?*U:YZ]:M@#:M8QTK6LIKUK&A-JUK7RM:VNO6M<(VK
44	M7.=*U[K:]:YXS:M>]\K7OOKUKX`-K&`'2]C"&O:PB$VL8A?+V,8Z]K&0C:QD
45	M)TO9REKVLIC-K&8WR]G.>O:SH`VM:$=+VM*:]K2H3:UJ5\O:UKKVM;"-K6QG
46	M2]O:VO:VN,VM;G?+V][Z]K?`#:YPATO<XAKWN,A-KG7R]SF.O>YT(VN==+
47	MW>I:][K8S:YVM\O=[GKWN^`-KWC'2][RFO>\Z$VO>M?+WO:Z][WPC:]\YTO?
48	M^MKWOOC-KW[WR]_^^O>_``ZP@`=,X`(;^,`(3K""%\S@!COXP1".L(0G3.$*
49	M6_C"&,ZPAC?,X0Y[^,,@#K&(1TSB$IOXQ"A.L8I7S.(6N_C%,(ZQC&=,XQK;
50	M^,8XSK&.=\SC'OOXQT`.LI"'3.0B&_G(2$ZRDI?,Y"8[^<E0CK4ITSEEOY
51	MREC.LI:WS.4N>_G+8`ZSF,=,YC*;^<QH3K.:U\SF-KOYS7".LYSG3.<ZV_G.
52	M>,ZSGO?,YS[[^<^`#K2@!TWH0AOZT(A.M(7S>A&._K1D(ZTI"=-Z4I;^M8
53	MSK2F-\WI3GOZTZ`.M:A'3>I2F_K4J$ZUJE?-ZE:[^M6PCK6L9TWK6MOZUKC.
54	MM:YWS>M>^_K7P`ZVL(=-[&(;^]C(3K:RE\WL9CO[V=".MK2G3>UJ6_O:V,ZV
55	MMK?-[6Y[^]O@#K>XQTWN<IO[W.A.M[K7S>YVN_O=\(ZWO.=-[WK;^][XSK>^
56	M]\WO?OO[WP`/N,`'3O""&_S@"$^XPA?.\(8[_.$0C[C$)T[QBEO\XAC/N,8W
57	MSO&.>_SC(`^YR$=.\I;_.0H3[G5\[REKO\Y3"/N<QG3O.:V_SF.,^YSG?.
58	M\Y[[_.=`#[K0AT[THAO]Z$A/NM7SO2F._WI4(^ZU=.]:I;_>I8S[K6M\[U
59	MKGO]ZV`/N]C'3O:RF_WL:$^[VM?.]K:[_>UPC[O<YT[WNMO][GC/N][WSO>^
60	M^_WO@`^\X`=/^,(;_O"(3[SB%\_XQCO^\9"/O.0G3_G*6_[RF,^\YC?/^<Y[
61	M_O.@#[WH1T_ZTIO^]*A/O>I7S_K6N_[UL(^][&=/^]K;_O:XS[WN=\_[WOO^
62	M]\`/OO"'3_SB&__XR$^^\I?/_.8[__G0C[[TIT_]ZEO_^MC/OO:WS_WN>__[
63	MX`^_^,=/_O*;__SH3[_ZU\_^]KO__?"/O_SG3__ZV__^^,^__O?/__[[__\`
64	M&(`".(`$6(`&>(`(F(`*N(`,V(`.^(`0&($2.($46($6>($8F($:N($<V($>
65	M^($@&((B.((D6((F>((HF((JN((LV((N^((P&(,R.(,T6(,V>(,XF(,ZN(,\
66	MV(,^^(-`&(1".(1$6(1&>(1(F(1*N(1,V(1.^(10&(52.(546(56>(58F(5:
67	MN(5<V(5>^(5@&(9B.(9D6(9F>(9HF(9JN(9LV(9N^(9P&(=R.(=T6(=V>(=X
68	MF(=ZN(=\V(=^^(>`&(B".(B$6(B&>(B(F(B*N(B,V(B.^(B0&(F2.(F46(F6
69	M>(F8F(F:N(F<V(F>^(F@&(JB.(JD6(JF>(JHF(JJN(JLV(JN^(JP&(NR.(NT
70	M6(NV>(NXF(NZN(N\V(N^^(O`&(S".(S$6(S&>(S(F(S*N(S,V(S.^(S0&(W2
71	M.(W46(W6>(W8F(W:N(W<V(W>^(W@&([B.([D6([F>([HF([JN([LV([N^([P
72	M&(_R.(_T6(_V>(_XF(_ZN(_\V(_^^(\`&9`".9`$69`&>9`(F9`*N9`,V9`.
73	M^9`0&9$2.9$469$6>9$8F9$:N9$<V9$>^9$@&9(B.9(D69(F>9(HF9(JN9(L
74	MV9(N^9(P&9,R.9,T69,V>9,XF9,ZN9,\V9,^^9-`&91".91$691&>91(F91*
75	MN91,V91.^910&952.9546956>958F95:N95<V95>^95@&99B.99D699F>99H
76	MF99JN99LV99N^99P&9=R.9=T69=V>9=XF9=ZN9=\V9=^^9>`&9B".9B$69B&
77	M>9B(F9B*N9B,V9B.^9B0&9F2.9F469F6>9F8F9F:N9F<V9F>^9F@&9JB.9JD
78	M69JF>9JHF9JJN9JLV9JN^9JP&9NR.9NT69NV>9NXF9NZN9N\V9N^^9O`&9S"
79	M.9S$69S&>9S(F9S*N9S,V9S.^9S0&9W2.9W469W6>9W8F9W:N9W<V9W>^9W@
80	M&9[B.9[D69[F>9[HF9[JN9[LV9[N^9[P&9_R.9_T69_V>9_XF9_ZN9_\V9_^
81	M^9\`&J`".J`$6J`&>J`(FJ`*NJ`,VJ`.^J`0&J$2.J$46J$6>J$8FJ$:NJ$<
82	MVJ$>^J$@&J(B.J(D6J(F>J(HFJ(JNJ(LVJ(N^J(P&J,R.J,T6J,V>J,XFJ,Z
83	MNJ,\VJ,^^J-`&J1".J1$6J1&>J1(FJ1*NJ1,VJ1.^J10&J52.J546J56>J58
84	MFJ5:NJ5<VJ5>^J5@&J9B.J9D6J9F>J9HFJ9JNJ9LVJ9N^J9P&J=R.J=T6J=V
85	M>J=XFJ=ZNJ=\VJ=^^J>`&JB".JB$6JB&>JB(FJB*NJB,VJB.^JB0&JF2.JF4
86	M6JF6>JF8FJF:NJF<VJF>^JF@&JJB.JJD6JJF>JJHFJJJNJJLVJJN^JJP&JNR
87	M.JNT6JNV>JNXFJNZNJN\VJN^^JO`&JS".JS$6JS&>JS(FJS*NJS,VJS.^JS0
88	M&JW2.JW46JW6>JW8FJW:NJW<VJW>^JW@&J[B.J[D6J[F>J[HFJ[JNJ[LVJ[N
89	M^J[P&J_R.J_T6J_V>J_XFJ_ZNJ_\VJ_^^J\`&[`".[`$6[`&>[`(F[`*N[`,
90	MV[`.^[`0&[$2.[$46[$6>[$8F[$:N[$<V[$>^[$@&[(B.[(D6[(F>[(HF[(J
91	MN[(LV[(N^[(P&[,R.[,T6[,V>[,XF[,ZN[,\V[,^^[-`&[1".[1$6[1&>[1(
92	MF[1*N[1,V[1.^[10&[52.[546[56>[58F[5:N[5<V[5>^[5@&[9B.[9D6[9F
93	M>[9HF[9JN[9LV[9N^[9P&[=R.[=T6[=V>[=XF[=ZN[=\V[=^^[>`&[B".[B$
94	M6[B&>[B(F[B*N[B,V[B.^[B0&[F2.[F46[F6>[F8F[F:N[F<V[F>^[F@&[JB
95	M.[JD6[JF>[JHF[JJN[JLV[JN^[JP&[NR.[NT6[NV>[NXF[NZN[N\V[N^^[O`
96	M&[S".[S$6[S&>[S(F[S*N[S,V[S.^[S0&[W2.[W46[W6>[W8F[W:N[W<V[W>
97	M^[W@&[[B.[[D6[[F>[[HF[[JN[[LV[[N^[[P&[_R.[_T6[_V>[_XF[_ZN[_\
98	MV[_^^[\`',`"/,`$7,`&?,`(G,`*O,`,W,`._,`0',$2/,$47,$6?,$8G,$:
99	MO,$<W,$>_,$@',(B/,(D7,(F?,(HG,(JO,(LW,(N_,(P',,R/,,T7,,V?,,X
100	MG,,ZO,,\W,,^_,-`',1"/,1$7,1&?,1(G,1*O,1,W,1._,10',52/,547,56
101	M?,58G,5:O,5<W,5>_,5@',9B/,9D7,9F?,9HG,9JO,9LW,9N_,9P',=R/,=T
102	M7,=V?,=XG,=ZO,=\W,=^_,>`',B"/,B$7,B&?,B(G,B*O,B,W,B._,B0',F2
103	M/,F47,F6?,F8G,F:O,F<W,F>_,F@',JB/,JD7,JF?,JHG,JJO,JLW,JN_,JP
104	M',NR/,NT7,NV?,NXG,NZO,N\W,N^_,O`',S"/,S$7,S&?,S(G,S*O,S,W,S.
105	M_,S0',W2/,W47,W6?,W8G,W:O,W<W,W>_,W@',[B/,[D7,[F?,[HG,[JO,[L
106	MW,[N_,[P',_R/,_T7,_V?,_XG,_ZO,_\W,_^_,\`'=`"/=`$7=`&?=`(G=`*
107	MO=`,W=`._=`0'=$2/=$47=$6?=$8G=$:O=$<W=$>_=$@'=(B/=(D7=(F?=(H
108	MG=(JO=(LW=(N_=(P'=,R/=,T7=,V?=,XG=,ZO=,\W=,^_=-`'=1"/=1$7=1&
109	M?=1(G=1*O=1,W=1._=10'=52/=547=56?=58G=5:O=5<W=5>_=5@'=9B/=9D
110	M7=9F?=9HG=9JO=9LW=9N_=9P'==R/==T7==V?==XG==ZO==\W==^_=>`'=B"
111	M/=B$7=B&?=B(G=B*O=B,W=B._=B0'=F2/=F47=F6?=F8G=F:O=F<W=F>_=F@
112	M'=JB/=JD7=JF?=JHG=JJO=JLW=JN_=JP'=NR/=NT7=NV?=NXG=NZO=N\W=N^
113	M_=O`'=S"/=S$7=S&?=S(G=S*O=S,W=S._=S0'=W2/=W47=W6?=W8G=W:O=W<
114	MW=W>_=W@'=[B/=[D7=[F?=[HG=[JO=[LW=[N_=[P'=_R/=_T7=_V?=_XG=_Z
115	MO=_\W=_^_=\`'N`"/N`$7N`&?N`(GN`*ON`,WN`._N`0'N$2/N$47N$6?N$8
116	MGN$:ON$<WN$>_N$@'N(B/N(D7N(F?N(HGN(JON(LWN(N_N(P'N,R/N,T7N,V
117	M?N,XGN,ZON,\WN,^_N-`'N1"/N1$7N1&?N1(GN1*ON1,WN1._N10'N52/N54
118	M7N56?N58GN5:ON5<WN5>_N5@'N9B/N9D7N9F?N9HGN9JON9LWN9N_N9P'N=R
119	M/N=T7N=V?N=XGN=ZON=\WN=^_N>`'NB"/NB$7NB&?NB(GNB*ONB,WNB._NB0
120	M'NF2/NF47NF6?NF8GNF:ONF<WNF>_NF@'NJB/NJD7NJF?NJHGNJJONJLWNJN
121	M_NJP'NNR/NNT7NNV?NNXGNNZONN\WNN^_NO`'NS"/NS$7NS&?NS(GNS*ONS,
122	MWNS._NS0'NW2/NW47NW6?NW8GNW:ONW<WNW>_NW@'N[B/N[D7N[F?N[HGN[J
123	MON[LWN[N_N[P'N_R/N_T7N_V?N_XGN_ZON_\WN_^_N\`'_`"/_`$7_`&?_`(
124	MG_`*O_`,W_`.__`0'_$2/_$47_$6?_$8G_$:O_$<W_$>__$@'_(B/_(D7_(F
125	M?_(HG_(JO_(LW_(N__(P'_,R/_,T7_,V?_,XG_,ZO_,\W_,^__-`'_1"/_1$
126	M7_1&?_1(G_1*O_1,W_1.__10'_52/_547_56?_58G_5:O_5<W_5>__5@'_9B
127	M/_9D7_9F?_9HG_9JO_9LW_9N__9P'_=R/_=T7_=V?_=XG_=ZO_=\W_=^__>`
128	M'_B"/_B$7_B&?_B(G_B*O_B,W_B.__B0'_F2/_F47_F6?_F8G_F:O_F<W_F>
129	M__F@'_JB/_JD7_JF?_JHG_JJO_JLW_JN__JP'_NR/_NT7_NV?_NXG_NZO_N\
130	MW_N^__O`'_S"/_S$7_S&?_S(G_S*O_S,W_S.__S0'_W2/_W47_W6?_W8G_W:
131	MO_W<W_W>__W@'_[B/_[D7_[F?_[HG_[JO_[LW_[N__[P'__R/__T7__V?__X
132	MG__ZO__\W__^__\`,``P`%(``N@`3R`"#`!L`%R``;H`-\@!`P`DK`"4@!
133	M*Z`%O(`8,`-JP`W(`3N@!_R`(#`$BL`12`)+H`D\@2@P!:K`%<@"6Z`+?($P
134	M,`;*P!E(`VN@#;R!.#`'ZL`=R`-[H`_\@4`P"`K!(4@$BZ`1/()(,`DJP27(
135	M!)N@$WR"4#`2L$I2`6KH!6\@E@P"VK!+<@%NZ`7_()@,`RP3%(!LN@&3R#
136	M:#`-JL$UR`;;H!M\@W`P#LK!.4@'ZZ`=O(-X,`_JP3W(!_N@'_R#@#`0"L)!
137	M2`@+H2$\A(@P$2K"1<@(&Z$C?(20,!)*PDE("2NA);R$F#`3:L)-R`D[H2?\
138	MA`P%(K"44@2Z$I/(6H,!6JPE7("ENA*WR%L#`6RL)92`MKH2V\A;@P%^K"
139	M7<@+>Z$O_(7`,!@PV%(#(NA,3R&R#`9L-ER`R;H3-\AM`P&DK#:4@-JZ$U
140	MO(;8,!MJPVW(#;NA-_R&X#`<BL-Q2`[+H3D\A^@P':K#=<@.VZ$[?(?P,![*
141	MPWE(#^NA/;R'^#`?ZL-]R`_[H3_\AP`Q(`K$@4@0"Z)!/(@(,2$JQ(7($!NB
142	M0WR($#$B2L2)2!%ID@)8"`TA+6C$C8@11$)'6`D;02C4@+;`$E!"6&`+,@$E
143	MBH08T!-@`@UP"40!!G#$F4@3FT)6D`H;@2I8!8UX!]!`&2@#;"`ML(63*!-J
144	MHE$\BD@Q2K%I<@4FZ)3?(I0,2IQ:E(%:NB5;R*6#$K:L6MR!6[HE?\BF`Q
145	M+(K%L4@6RZ)9/(MH,2VJQ;7(%MNB6WR+<#$NRL6Y2!?KHEV\BW@Q+^K%O<@7
146	M^Z)?_(N`,3`QL%(&`NC83R,B#$QL;%R!@;HV-\C)`Q,DK&R4@9*Z-EO(R8
147	),3-JQLW(&0$C
148	`
149	end




  archive_write_set_format_xar(a);
  archive_write_add_filter_none(a);
  size_t used, buffsize = 1500;
  char *buff = malloc(buffsize);
  archive_write_open_memory(a, buff, buffsize, &used);

  struct archive_entry *ae = archive_entry_new();

	assertA(0 == archive_read_next_header(a, &entry));
	buf_size = (size_t) archive_entry_size(entry);
	assertA(buf_size == 12);
	buf = malloc(buf_size);
	assertA(NULL != buf);
	assertA(buf_size == (size_t) archive_read_data(a, buf, buf_size));
	free(buf);

	assertA(0 == archive_read_next_header(a, &entry));
	buf_size = (size_t) archive_entry_size(entry);
	assertA(buf_size == 12);
	buf = malloc(buf_size);
	assertA(NULL != buf);
	assertA(buf_size == (size_t) archive_read_data(a, buf, buf_size));
	free(buf);

        verify(archive12, sizeof(archive12), verify12, NULL, GZIP);
	verifyB(archive13, sizeof(archive13));
}

DEFINE_TEST(test_read_format_xar_duplicate_filename_node)
{
	static const char *reffiles[] =
	{
		"test_read_format_xar_duplicate_filename_node.xar",
		NULL
	};
	struct archive_entry *ae;
	struct archive *a;
	int r;

	extract_reference_files(reffiles);
	assert((a = archive_read_new()) != NULL);
	assertA(0 == archive_read_support_filter_all(a));

	r = archive_read_support_format_xar(a);
	if (r == ARCHIVE_WARN) {
		skipping("xar reading not fully supported on this platform");
		assertEqualInt(ARCHIVE_OK, archive_read_free(a));
		return;
	}

	assertA(0 == archive_read_open_filenames(a, reffiles, 10240));

	assertA(0 == archive_read_next_header(a, &ae));
	assertEqualString("File", archive_entry_pathname(ae));

	assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
	assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}

Added Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_xar_duplicate_filename_node.xar.uu (+14 lines)
1	begin 644 test_read_format_xar_duplicate_filename_node.xar
2	M>&%R(0`<``$````````!EP````````.]`````7B<A5-);H,P%-U7ZAT0>VIC
3	MC('((;N<H-UT][$-L<H0@1,E.7T-`0H=TI6?__OSP'>7JG3.JNUT4V]=_P6[
4	MCJI%(W5=;-VWU[T7N[OT^8E?H+6/XW#3B`%8*%H%QMIY1E<J)9A0#S//IZ\$
5	M;PC=^(RCM<ID=U#BHSM53F>NI=JZW0%\=R0MW>1YITR*.1K1S'3ZUL?A:`"C
6	M-S2YFP2Y+I6CI:UFX;0&&W]O&8X&^#]AKD>5Y@,QP)G0=2-M&E'"DIBC^V\F
7	MI3IKH>HF]0-&68!]PM$LF[6JW@8S9CM4K<Q/6O:%]\\L*^ZR8BD3O[<<)^^V
8	M'XM>][$>J%9K57B@"FM5"0;FG_V7JB[,(?5MHB-<D.,<R<^1SD-=S7203VLX
9	M;0D<CZ46PS:ABU?<]-%UT-(`6G'09R6]W_<KIG$LJ9\%"6!)"&80R#`)<"!R
10	M'(DL)T`CH2384K\[6J5U,2T(\V>8#&+(0L`DQED2!@!)1(,PS^.$,I&)+"-1
11	M&`*)./KIZ:N]:-%?COHMO%\?NI\?1_T]?@(L`P/8\;44V2:R;"\D48GC?CRL
12	C(UAG)C5XG./E`@``)@`8>)R%4TEN@S`4W5?J'1![:F.,@<@`
13	`
14	end

Lines 49-55 DEFINE_TEST(test_read_format_zip_nested) Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_zip_nested.c (-1 / +1 lines)
49		49
50	/* Save contents of inner Zip. */	50	/* Save contents of inner Zip. */
51	innerLength = (size_t)archive_entry_size(ae);	51	innerLength = (size_t)archive_entry_size(ae);
52	inner = calloc(innerLength, sizeof(char));	52	inner = calloc(innerLength, sizeof(*inner));
53	assertEqualInt(innerLength, archive_read_data(a, inner, innerLength));	53	assertEqualInt(innerLength, archive_read_data(a, inner, innerLength));
54		54
55	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));	55	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));

Lines 41-47 DEFINE_TEST(test_read_format_zip_traditional_encryption_data) Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_zip_traditional_encryption_data.c (-1 / +1 lines)
41	assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));	41	assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
42	if (ARCHIVE_OK != archive_write_set_options(a,	42	if (ARCHIVE_OK != archive_write_set_options(a,
43	"zip:encryption=traditional")) {	43	"zip:encryption=traditional")) {
44	skipping("This system does not have cryptographic liberary");	44	skipping("This system does not have cryptographic library");
45	archive_write_free(a);	45	archive_write_free(a);
46	return;	46	return;
47	}	47	}

Lines 38-44 test_winzip_aes(const char *refname, int need_libz) Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_zip_winzip_aes.c (-1 / +1 lines)
38	assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));	38	assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
39	if (ARCHIVE_OK != archive_write_set_options(a,	39	if (ARCHIVE_OK != archive_write_set_options(a,
40	"zip:encryption=aes256")) {	40	"zip:encryption=aes256")) {
41	skipping("This system does not have cryptographic liberary");	41	skipping("This system does not have cryptographic library");
42	archive_write_free(a);	42	archive_write_free(a);
43	return;	43	return;
44	}	44	}

Lines 39-45 DEFINE_TEST(test_read_format_zip_winzip_aes256_large) Link Here

(-)b/contrib/libarchive/libarchive/test/test_read_format_zip_winzip_aes_large.c (-1 / +1 lines)
39	assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));	39	assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
40	if (ARCHIVE_OK != archive_write_set_options(a,	40	if (ARCHIVE_OK != archive_write_set_options(a,
41	"zip:encryption=aes256")) {	41	"zip:encryption=aes256")) {
42	skipping("This system does not have cryptographic liberary");	42	skipping("This system does not have cryptographic library");
43	archive_write_free(a);	43	archive_write_free(a);
44	return;	44	return;
45	}	45	}




	int i, r, use_prog;

	buffsize = 2000000;
	assert(NULL != (buff = malloc(buffsize)));
	if (buff == NULL)
		return;

	datasize = 10000;
	assert(NULL != (data = malloc(datasize)));
	if (data == NULL) {
		free(buff);
		return;





static void create_sparse_file(const char *, const struct sparse *);

/* This should be large enough that any OS/filesystem that
 * does support sparse files is certain to store a gap this big
 * as a hole. */
/* A few data points:
 * = ZFS on FreeBSD needs this to be at least 200kB
 * = macOS APFS needs this to be at least 4096x4097 bytes
 *
 * 32MiB here is bigger than either of the above.
 */
#define MIN_HOLE (32 * 1024UL * 1024UL)

#if defined(_WIN32) && !defined(__CYGWIN__)
#include <winioctl.h>

Lines 99-105 memory_write(struct archive a, void _private, const void *buff, size_t size) Link Here

(-)b/contrib/libarchive/libarchive/test/test_tar_large.c (-1 / +1 lines)
99	} else {	99	} else {
100	/* Yes, we're assuming the very first write is metadata. */	100	/* Yes, we're assuming the very first write is metadata. */
101	/* It's header or metadata, copy and save it. */	101	/* It's header or metadata, copy and save it. */
102	block = (struct memblock )malloc(sizeof(block));	102	block = malloc(sizeof(*block));
103	memset(block, 0, sizeof(*block));	103	memset(block, 0, sizeof(*block));
104	block->size = size;	104	block->size = size;
105	block->buff = malloc(size);	105	block->buff = malloc(size);




	assertEqualMem(buff, "\xE8\xA1\xA8.txt", 7);
}

DEFINE_TEST(test_ustar_filename_encoding_UTF16_win)
{
#if !defined(_WIN32) || defined(__CYGWIN__)
	skipping("This test is meant to verify unicode string handling"
		" on Windows with UTF-16 names");
	return;
#else
	struct archive *a;
	struct archive_entry *entry;
	char buff[4096];
	size_t used;

	/*
	 * Don't call setlocale because we're verifying that the '_w' functions
	 * work as expected when 'hdrcharset' is UTF-8
	 */

	/* Part 1: file */
	a = archive_write_new();
	assertEqualInt(ARCHIVE_OK, archive_write_set_format_ustar(a));
	if (archive_write_set_options(a, "hdrcharset=UTF-8") != ARCHIVE_OK) {
		skipping("This system cannot convert character-set"
		    " from UTF-16 to UTF-8.");
		archive_write_free(a);
		return;
	}
	assertEqualInt(ARCHIVE_OK,
	    archive_write_open_memory(a, buff, sizeof(buff), &used));

	entry = archive_entry_new2(a);
	/* Set the filename using a UTF-16 string */
	archive_entry_copy_pathname_w(entry, L"\u8868.txt");
	archive_entry_set_filetype(entry, AE_IFREG);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
	archive_entry_free(entry);
	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	/* Check UTF-8 version. */
	assertEqualMem(buff, "\xE8\xA1\xA8.txt", 7);

	/* Part 2: directory */
	a = archive_write_new();
	assertEqualInt(ARCHIVE_OK, archive_write_set_format_ustar(a));
	assertEqualInt(ARCHIVE_OK, archive_write_set_options(a, "hdrcharset=UTF-8"));
	assertEqualInt(ARCHIVE_OK,
	    archive_write_open_memory(a, buff, sizeof(buff), &used));

	entry = archive_entry_new2(a);
	/* Set the directory name using a UTF-16 string */
	/* NOTE: Explicitly not adding trailing slash to test that code path */
	archive_entry_copy_pathname_w(entry, L"\u8868");
	archive_entry_set_filetype(entry, AE_IFDIR);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
	archive_entry_free(entry);
	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	/* Check UTF-8 version. */
	assertEqualMem(buff, "\xE8\xA1\xA8/", 4);

	/* Part 3: symlink */
	a = archive_write_new();
	assertEqualInt(ARCHIVE_OK, archive_write_set_format_ustar(a));
	assertEqualInt(ARCHIVE_OK, archive_write_set_options(a, "hdrcharset=UTF-8"));
	assertEqualInt(ARCHIVE_OK,
	    archive_write_open_memory(a, buff, sizeof(buff), &used));

	entry = archive_entry_new2(a);
	/* Set the symlink target using a UTF-16 string */
	archive_entry_set_pathname(entry, "link.txt");
	archive_entry_copy_symlink_w(entry, L"\u8868.txt");
	archive_entry_set_filetype(entry, AE_IFLNK);
	archive_entry_set_symlink_type(entry, AE_SYMLINK_TYPE_FILE);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
	archive_entry_free(entry);
	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	/* Check UTF-8 version. */
	assertEqualMem(buff + 157, "\xE8\xA1\xA8.txt", 7);

	/* Part 4: hardlink */
	a = archive_write_new();
	assertEqualInt(ARCHIVE_OK, archive_write_set_format_ustar(a));
	assertEqualInt(ARCHIVE_OK, archive_write_set_options(a, "hdrcharset=UTF-8"));
	assertEqualInt(ARCHIVE_OK,
	    archive_write_open_memory(a, buff, sizeof(buff), &used));

	entry = archive_entry_new2(a);
	/* Set the symlink target using a UTF-16 string */
	archive_entry_set_pathname(entry, "link.txt");
	archive_entry_copy_hardlink_w(entry, L"\u8868.txt");
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
	archive_entry_free(entry);
	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	/* Check UTF-8 version. */
	assertEqualMem(buff + 157, "\xE8\xA1\xA8.txt", 7);
#endif
}




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2024 Mostyn Bramley-Moore <mostyn@antipode.se>
 */

#include "test.h"

#include <stdlib.h>

#if defined(_WIN32) && !defined(__CYGWIN__)
#define UNLINK _unlink
#else
#include <unistd.h>
#define UNLINK unlink
#endif

/*
 * Exercise security checks that should prevent writing absolute paths
 * when extracting archives.
 */
DEFINE_TEST(test_write_disk_secure_noabsolutepaths)
{
	struct archive *a, *ad;
	struct archive_entry *ae;

	char buff[10000];

	size_t used;

	// Create an archive_write object.
	assert((a = archive_write_new()) != NULL);
	assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
	assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
	assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff), &used));

	// Create an absolute path for a test file inside testworkdir.
	const char *entry_suffix = "/badfile";
	size_t entry_suffix_length = strlen(entry_suffix);
	size_t testworkdir_length = strlen(testworkdir);
	size_t temp_absolute_file_name_length = testworkdir_length + entry_suffix_length;
	char *temp_absolute_file_name = calloc(1, temp_absolute_file_name_length + 1); // +1 for null character.
	assertEqualInt(snprintf(temp_absolute_file_name, temp_absolute_file_name_length + 1, "%s%s", testworkdir, entry_suffix),
		temp_absolute_file_name_length);

	// Convert to a unix-style path, so we can compare it to the entry
	// path when reading back the archive.
	for (char *p = temp_absolute_file_name; *p != '\0'; p++)
		if (*p == '\\') *p = '/';

	// Add a regular file entry with an absolute path.
	assert((ae = archive_entry_new()) != NULL);
	archive_entry_copy_pathname(ae, temp_absolute_file_name);
	archive_entry_set_mode(ae, S_IFREG | 0777);
	archive_entry_set_size(ae, 6);
	assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
	archive_entry_free(ae);
	assertEqualInt(6, archive_write_data(a, "hello", 6));
	assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	// Now try to extract the data.
	assert((a = archive_read_new()) != NULL);
	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
	assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
	assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));

	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
	assertEqualString(temp_absolute_file_name, archive_entry_pathname(ae));
	assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
	assertEqualInt(AE_IFREG | 0777, archive_entry_mode(ae));
	assertEqualInt(6, archive_entry_size(ae));

	// This should succeed.
	assertEqualInt(ARCHIVE_OK, archive_read_extract(a, ae, 0));
	UNLINK(temp_absolute_file_name);

	// This should fail, since the archive entry has an absolute path.
	assert(ARCHIVE_OK != archive_read_extract(a, ae, ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS));

	// This should also fail.
	assert((ad = archive_write_new()) != NULL);
	assertEqualInt(ARCHIVE_OK, archive_write_disk_set_options(a, ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS));
	assert(ARCHIVE_OK != archive_read_extract2(a, ae, ad));

	assertEqualInt(ARCHIVE_OK, archive_write_free(ad));
	assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}

Lines 41-50 DEFINE_TEST(test_write_filter_b64encode) Link Here

(-)b/contrib/libarchive/libarchive/test/test_write_filter_b64encode.c (-2 / +2 lines)
41	int i;	41	int i;
42		42
43	buffsize = 2000000;	43	buffsize = 2000000;
44	assert(NULL != (buff = (char *)malloc(buffsize)));	44	assert(NULL != (buff = malloc(buffsize)));
45		45
46	datasize = 10000;	46	datasize = 10000;
47	assert(NULL != (data = (char *)malloc(datasize)));	47	assert(NULL != (data = malloc(datasize)));
48	memset(data, 0, datasize);	48	memset(data, 0, datasize);
49		49
50	/*	50	/*




	int i, r, use_prog;

	buffsize = 2000000;
	assert(NULL != (buff = malloc(buffsize)));
	if (buff == NULL)
		return;

	datasize = 10000;
	assert(NULL != (data = malloc(datasize)));
	if (data == NULL) {
		free(buff);
		return;

Lines 43-52 DEFINE_TEST(test_write_filter_compress) Link Here

(-)b/contrib/libarchive/libarchive/test/test_write_filter_compress.c (-2 / +2 lines)
43	int i;	43	int i;
44		44
45	buffsize = 1000000;	45	buffsize = 1000000;
46	assert(NULL != (buff = (char *)malloc(buffsize)));	46	assert(NULL != (buff = malloc(buffsize)));
47		47
48	datasize = 10000;	48	datasize = 10000;
49	assert(NULL != (data = (char *)malloc(datasize)));	49	assert(NULL != (data = malloc(datasize)));
50	memset(data, 0, datasize);	50	memset(data, 0, datasize);
51		51
52	assert((a = archive_write_new()) != NULL);	52	assert((a = archive_write_new()) != NULL);




	int i, r, use_prog = 0;

	buffsize = 2000000;
	assert(NULL != (buff = malloc(buffsize)));
	if (buff == NULL)
		return;

	datasize = 10000;
	assert(NULL != (data = malloc(datasize)));
	if (data == NULL) {
		free(buff);
		return;




	int r, use_prog = 0;

	buffsize = 10000;
	assert(NULL != (buff = malloc(buffsize)));
	if (buff == NULL)
		return;

	datasize = 10000;
	assert(NULL != (data = malloc(datasize)));
	if (data == NULL) {
		free(buff);
		return;

Lines 46-55 DEFINE_TEST(test_write_filter_lrzip) Link Here

(-)b/contrib/libarchive/libarchive/test/test_write_filter_lrzip.c (-2 / +2 lines)
46	}	46	}
47		47
48	buffsize = 2000000;	48	buffsize = 2000000;
49	assert(NULL != (buff = (char *)malloc(buffsize)));	49	assert(NULL != (buff = malloc(buffsize)));
50		50
51	datasize = 10000;	51	datasize = 10000;
52	assert(NULL != (data = (char *)malloc(datasize)));	52	assert(NULL != (data = malloc(datasize)));
53	memset(data, 0, datasize);	53	memset(data, 0, datasize);
54		54
55	/*	55	/*




	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	buffsize = 2000000;
	assert(NULL != (buff = malloc(buffsize)));

	datasize = 10000;
	assert(NULL != (data = calloc(datasize, 1)));
	filecount = 10;

	/*

	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	buffsize = 2000000;
	assert(NULL != (buff = malloc(buffsize)));

	datasize = 10000;
	assert(NULL != (data = calloc(datasize, 1)));
	filecount = 10;

	/*




	int i, r;

	buffsize = 2000000;
	assert(NULL != (buff = malloc(buffsize)));
	if (buff == NULL)
		return;

	datasize = 10000;
	assert(NULL != (data = malloc(datasize)));
	if (data == NULL) {
		free(buff);
		return;




	int i, r;

	buffsize = 2000000;
	assert(NULL != (buff = malloc(buffsize)));
	if (buff == NULL)
		return;

	datasize = 10000;
	assert(NULL != (data = malloc(datasize)));
	if (data == NULL) {
		free(buff);
		return;

Lines 52-61 DEFINE_TEST(test_write_filter_lzop) Link Here

(-)b/contrib/libarchive/libarchive/test/test_write_filter_lzop.c (-2 / +2 lines)
52	}	52	}
53		53
54	buffsize = 2000000;	54	buffsize = 2000000;
55	assert(NULL != (buff = (char *)malloc(buffsize)));	55	assert(NULL != (buff = malloc(buffsize)));
56		56
57	datasize = 10000;	57	datasize = 10000;
58	assert(NULL != (data = (char *)calloc(datasize, 1)));	58	assert(NULL != (data = calloc(datasize, 1)));
59	filecount = 10;	59	filecount = 10;
60		60
61	/*	61	/*

Lines 41-50 DEFINE_TEST(test_write_filter_uuencode) Link Here

(-)b/contrib/libarchive/libarchive/test/test_write_filter_uuencode.c (-2 / +2 lines)
41	int i;	41	int i;
42		42
43	buffsize = 2000000;	43	buffsize = 2000000;
44	assert(NULL != (buff = (char *)malloc(buffsize)));	44	assert(NULL != (buff = malloc(buffsize)));
45		45
46	datasize = 10000;	46	datasize = 10000;
47	assert(NULL != (data = (char *)malloc(datasize)));	47	assert(NULL != (data = malloc(datasize)));
48	memset(data, 0, datasize);	48	memset(data, 0, datasize);
49		49
50	/*	50	/*




	int i, r;

	buffsize = 2000000;
	assert(NULL != (buff = malloc(buffsize)));
	if (buff == NULL)
		return;

	datasize = 10000;
	assert(NULL != (data = malloc(datasize)));
	if (data == NULL) {
		free(buff);
		return;




	int i, r;

	buffsize = 2000000;
	assert(NULL != (buff = malloc(buffsize)));
	if (buff == NULL)
		return;

	datasize = 10000;
	assert(NULL != (data = malloc(datasize)));
	if (data == NULL) {
		free(buff);
		return;

	    archive_write_set_filter_option(a, NULL, "max-frame-out", "1GB"));
#endif
#if ZSTD_VERSION_NUMBER >= MINVER_LONG
	assertEqualIntA(a, ARCHIVE_OK,
	    archive_write_set_filter_option(a, NULL, "long", "23"));
		    archive_write_set_filter_option(a, NULL, "long", "26"));
	else
		assertEqualIntA(a, ARCHIVE_OK,
		    archive_write_set_filter_option(a, NULL, "long", "27"));
	assertEqualIntA(a, ARCHIVE_FAILED,
	    archive_write_set_filter_option(a, NULL, "long", "-1")); /* negative */
#endif

Lines 321-327 DEFINE_TEST(test_write_format_iso9660_filename) Link Here

(-)b/contrib/libarchive/libarchive/test/test_write_format_iso9660_filename.c (-1 / +1 lines)
321	*/	321	*/
322	fcnt = create_iso_image(buff, buffsize, &used, NULL);	322	fcnt = create_iso_image(buff, buffsize, &used, NULL);
323		323
324	fns.names = (char *)malloc(sizeof(char ) * fcnt);	324	fns.names = malloc(sizeof(char ) fcnt);
325	assert(fns.names != NULL);	325	assert(fns.names != NULL);
326	if (fns.names == NULL) {	326	if (fns.names == NULL) {
327	free(buff);	327	free(buff);




	assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
	if (ARCHIVE_OK != archive_write_set_options(a,
		    "zip:encryption=zipcrypt")) {
		skipping("This system does not have cryptographic library");
		archive_write_free(a);
		free(buff);
		return;

	assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
	if (ARCHIVE_OK != archive_write_set_options(a, "zip:encryption=aes128"))
	{
		skipping("This system does not have cryptographic library");
		archive_write_free(a);
		free(buff);
		return;

	assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
	if (ARCHIVE_OK != archive_write_set_options(a, "zip:encryption=aes256"))
	{
		skipping("This system does not have cryptographic library");
		archive_write_free(a);
		free(buff);
		return;

Lines 205-211 static void verify_contents(const char *zip_buff, size_t size) Link Here

(-)b/contrib/libarchive/libarchive/test/test_write_format_zip_entry_size_unset.c (-1 / +1 lines)
205	assertEqualInt(i4(data_descriptor + 4), crc);	205	assertEqualInt(i4(data_descriptor + 4), crc);
206	/* Check compressed size */	206	/* Check compressed size */
207	assertEqualInt(i4(data_descriptor + 8), sizeof(file_data1) + sizeof(file_data2));	207	assertEqualInt(i4(data_descriptor + 8), sizeof(file_data1) + sizeof(file_data2));
208	/* Chcek uncompresed size */	208	/* Check uncompressed size */
209	assertEqualInt(i4(data_descriptor + 12), sizeof(file_data1) + sizeof(file_data2));	209	assertEqualInt(i4(data_descriptor + 12), sizeof(file_data1) + sizeof(file_data2));
210		210
211	/* Get folder entry in central directory */	211	/* Get folder entry in central directory */

Lines 96-102 memory_write(struct archive a, void _private, const void *buff, size_t size) Link Here

(-)b/contrib/libarchive/libarchive/test/test_write_format_zip_large.c (-1 / +1 lines)
96	} else {	96	} else {
97	/* Yes, we're assuming the very first write is metadata. */	97	/* Yes, we're assuming the very first write is metadata. */
98	/* It's header or metadata, copy and save it. */	98	/* It's header or metadata, copy and save it. */
99	block = (struct fileblock )malloc(sizeof(block));	99	block = malloc(sizeof(*block));
100	memset(block, 0, sizeof(*block));	100	memset(block, 0, sizeof(*block));
101	block->size = (int)size;	101	block->size = (int)size;
102	block->buff = malloc(size);	102	block->buff = malloc(size);

Lines 71-77 DEFINE_TEST(test_write_format_zip_stream) Link Here

(-)b/contrib/libarchive/libarchive/test/test_write_format_zip_stream.c (+5 lines)
71	unsigned long crc;	71	unsigned long crc;
72	unsigned long compressed_size = 0;	72	unsigned long compressed_size = 0;
73	int file_perm = 00644;	73	int file_perm = 00644;
		74	#ifdef HAVE_ZLIB_H
74	int zip_version = 20;	75	int zip_version = 20;
		76	#else
		77	int zip_version = 10;
		78	#endif
75	int zip_compression = 8;	79	int zip_compression = 8;
76	short file_uid = 10, file_gid = 20;	80	short file_uid = 10, file_gid = 20;
77	unsigned char buff, buffend, *p;	81	unsigned char buff, buffend, *p;
Lines 82-87 DEFINE_TEST(test_write_format_zip_stream) Link Here
82	const char *file_name = "file";	86	const char *file_name = "file";
83		87
84	#ifndef HAVE_ZLIB_H	88	#ifndef HAVE_ZLIB_H
		89	zip_version = 10;
85	zip_compression = 0;	90	zip_compression = 0;
86	#endif	91	#endif
87		92




/*-
 * Copyright (c) 2024 Yang Zhou
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "test.h"

static void
test_with_hdrcharset(const char *charset)
{
	static const char *raw_path = "dir_stored\\dir1/file";
	static const char *replaced = "dir_stored/dir1/file";
	struct archive *a;
	size_t used;
	size_t buffsize = 1000000;
	char *buff;

	buff = malloc(buffsize);

	/* Create a new archive in memory. */
	assert((a = archive_write_new()) != NULL);
	assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a));
	assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
	if (charset != NULL) {
		assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_option(a, "zip", "hdrcharset", charset));
	}
	assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used));

	/*
	 * Write a file with mixed '/' and '\'
	 */
	struct archive_entry *ae;
	assert((ae = archive_entry_new()) != NULL);
	archive_entry_set_mtime(ae, 1, 10);
	archive_entry_copy_pathname(ae, raw_path);
	archive_entry_set_mode(ae, AE_IFREG | 0755);
	archive_entry_set_size(ae, 0);
	assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
	archive_entry_free(ae);

	assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
	assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
	dumpfile("constructed.zip", buff, used);

	/*
	 * Check if the generated archive contains and only contains expected path.
	 * Intentionally avoid using `archive_read_XXX` functions because it silently replaces '\' with '/',
	 * making it difficult to get the exact path written in the archive.
	 */
#if defined(_WIN32) && !defined(__CYGWIN__)
	const char *expected = replaced;
	const char *unexpected = raw_path;
#else
	const char *expected = raw_path;
	const char *unexpected = replaced;
#endif
	int expected_found = 0;
	int unexpected_found = 0;
	size_t len = strlen(raw_path);
	for (char *ptr = buff; ptr < (buff + used - len); ptr++) {
		if (memcmp(ptr, expected, len) == 0)
			++expected_found;
		if (memcmp(ptr, unexpected, len) == 0)
			++unexpected_found;
	}
	failure("should find expected path in both local and central header (charset=%s)", charset);
	assertEqualInt(2, expected_found);
	failure("should not find unexpected path in anywhere (charset=%s)", charset);
	assertEqualInt(0, unexpected_found);
}

DEFINE_TEST(test_write_format_zip_windows_path)
{
	test_with_hdrcharset(NULL);
#if defined(_WIN32) && !defined(__CYGWIN__) || HAVE_ICONV
	test_with_hdrcharset("ISO-8859-1");
	test_with_hdrcharset("UTF-8");
#endif
}




	assertEqualInt(0, buff[7]);
	assertEqualMem(buff + 30, "abcABC", 6);
}

DEFINE_TEST(test_zip_filename_encoding_UTF16_win)
{
#if !defined(_WIN32) || defined(__CYGWIN__)
	skipping("This test is meant to verify unicode string handling"
		" on Windows with UTF-16 names");
	return;
#else
	struct archive *a;
	struct archive_entry *entry;
	char buff[4096];
	size_t used;

	/*
	 * Don't call setlocale because we're verifying that the '_w' functions
	 * work as expected when 'hdrcharset' is UTF-8
	 */

	/* Part 1: file */
	a = archive_write_new();
	assertEqualInt(ARCHIVE_OK, archive_write_set_format_zip(a));
	if (archive_write_set_options(a, "hdrcharset=UTF-8") != ARCHIVE_OK) {
		skipping("This system cannot convert character-set"
		    " from UTF-16 to UTF-8.");
		archive_write_free(a);
		return;
	}
	assertEqualInt(ARCHIVE_OK,
	    archive_write_open_memory(a, buff, sizeof(buff), &used));

	entry = archive_entry_new2(a);
	/* Set the filename using a UTF-16 string */
	archive_entry_copy_pathname_w(entry, L"\u8868.txt");
	archive_entry_set_filetype(entry, AE_IFREG);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
	archive_entry_free(entry);
	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	/* A bit 11 of general purpose flag should be 1,
	 * which indicates the filename charset is UTF-8. */
	assertEqualInt(0x08, buff[7]);
	/* Check UTF-8 version. */
	assertEqualMem(buff + 30, "\xE8\xA1\xA8.txt", 7);

	/* Part 2: directory */
	a = archive_write_new();
	assertEqualInt(ARCHIVE_OK, archive_write_set_format_zip(a));
	assertEqualInt(ARCHIVE_OK, archive_write_set_options(a, "hdrcharset=UTF-8"));
	assertEqualInt(ARCHIVE_OK,
	    archive_write_open_memory(a, buff, sizeof(buff), &used));

	entry = archive_entry_new2(a);
	/* Set the directory name using a UTF-16 string */
	/* NOTE: Explicitly not adding trailing slash to test that code path */
	archive_entry_copy_pathname_w(entry, L"\u8868");
	archive_entry_set_filetype(entry, AE_IFDIR);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
	archive_entry_free(entry);
	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	/* A bit 11 of general purpose flag should be 1,
	 * which indicates the filename charset is UTF-8. */
	assertEqualInt(0x08, buff[7]);
	/* Check UTF-8 version. */
	assertEqualMem(buff+ 30, "\xE8\xA1\xA8/", 4);

	/* Part 3: symlink */
	a = archive_write_new();
	assertEqualInt(ARCHIVE_OK, archive_write_set_format_zip(a));
	assertEqualInt(ARCHIVE_OK, archive_write_set_options(a, "hdrcharset=UTF-8"));
	assertEqualInt(ARCHIVE_OK,
	    archive_write_open_memory(a, buff, sizeof(buff), &used));

	entry = archive_entry_new2(a);
	/* Set the symlink target using a UTF-16 string */
	archive_entry_set_pathname(entry, "link.txt");
	archive_entry_copy_symlink_w(entry, L"\u8868.txt");
	archive_entry_set_filetype(entry, AE_IFLNK);
	archive_entry_set_symlink_type(entry, AE_SYMLINK_TYPE_FILE);
	archive_entry_set_size(entry, 0);
	assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
	archive_entry_free(entry);
	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	/* A bit 11 of general purpose flag should be 0,
	 * because the file name is ASCII. */
	assertEqualInt(0, buff[7]);
	/* Check UTF-8 version. */
	assertEqualMem(buff + 38, "\xE8\xA1\xA8.txt", 7);

	/* NOTE: ZIP does not support hardlinks */
#endif
}




.\"
.\" SPDX-License-Identifier: BSD-2-Clause
.\"
.\" Copyright (c) 2003-2007 Tim Kientzle
.\" Copyright (c) 2017 Martin Matuska
.\" All rights reserved.
.\"
.\" Redistribution and use in source and binary forms, with or without
.\" modification, are permitted provided that the following conditions
.\" are met:
.\" 1. Redistributions of source code must retain the above copyright
.\"    notice, this list of conditions and the following disclaimer.
.\" 2. Redistributions in binary form must reproduce the above copyright
.\"    notice, this list of conditions and the following disclaimer in the
.\"    documentation and/or other materials provided with the distribution.
.\"
.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
.\" SUCH DAMAGE.
.\"
.Dd April 23, 2024
.Dt TAR 1
.Os




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2008 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "bsdtar_platform.h"

#ifdef HAVE_LANGINFO_H
#include <langinfo.h>
#endif
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif
#ifdef HAVE_LOCALE_H
#include <locale.h>
#endif




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef BSDTAR_H_INCLUDED




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*

#define __LA_NORETURN       __attribute__((__noreturn__))
#elif defined(_MSC_VER)
#define __LA_NORETURN __declspec(noreturn)
#else
#define __LA_NORETURN
#endif





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2008 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "bsdtar_platform.h"

	struct filter_set *new_ptr;
	char *new_filter;

	new_ptr = realloc(cset->filters,
	    sizeof(*cset->filters) * (cset->filter_count + 1));
	if (new_ptr == NULL)
		lafe_errc(1, 0, "No memory");




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "bsdtar_platform.h"




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2008 Joerg Sonnenberger
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "bsdtar_platform.h"




/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2017 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/* Every test program should #include "test.h" as the first thing. */




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"


#define LIMIT_USTAR 100

static void
verify_tree(size_t limit, const char *format)
{
	char name1[260];
	char name2[260];

		/* Verify a file named "f/abcdef..." */
		snprintf(name1, sizeof(name1), "f/%s", filenames[i]);
		if (i <= limit) {
			failure("Verifying %s", format);
			assertFileExists(name1);
			assertFileContents(name1, (int)strlen(name1), name1);
		}

		snprintf(name2, sizeof(name2), "l/%s", filenames[i]);
		if (i + 2 <= limit) {
			/* Verify hardlink "l/abcdef..." */
			failure("Verifying %s", format);
			assertIsHardlink(name1, name2);
			/* Verify hardlink "m/abcdef..." */
			name2[0] = 'm';

			/* Verify symlink "s/abcdef..." */
			snprintf(name1, sizeof(name1), "s/%s", filenames[i]);
			snprintf(name2, sizeof(name2), "../f/%s", filenames[i]);
			if (strlen(name2) <= limit) {
				failure("Verifying %s", format);
				assertIsSymlink(name1, name2, 0);
			}
		}

		/* Verify dir "d/abcdef...". */
		snprintf(name1, sizeof(name1), "d/%s", filenames[i]);
		if (i + 1 <= limit) { /* +1 for trailing slash */
			failure("Verifying %s", format);
			if (assertIsDir(name1, -1)) {
				/* TODO: opendir/readdir this
				 * directory and make sure

			char dir[2];
			dir[0] = *dp; dir[1] = '\0';
			d = opendir(dir);
			failure("Unable to open dir '%s' for testing %s", dir, format);
			if (!assert(d != NULL))
				continue;
			while ((de = readdir(d)) != NULL) {

}

static void
copy_basic(const char *extra_args, const char *name)
{
	int r;

	/* NOTE: for proper operation on cygwin-1.5 and windows, the
	 * length of the name of the directory below must be
	 * less than or equal to the length of the name of the original
	 * directory, "original"  This restriction derives from the
	 * extremely limited pathname lengths on those platforms.
	 */
	assertMakeDir(name, 0775);
	assertEqualInt(0, chdir(name));

	/*
	 * Use the tar program to create an archive.
	 */
	r = systemf("%s cf archive %s -C ../original f d l m s >pack.out 2>pack.err",
	    testprog, extra_args);
	failure("Error invoking \"%s cf archive %s\"", testprog, extra_args);
	assertEqualInt(r, 0);

	/* Verify that nothing went to stdout or stderr. */

	assertEmptyFile("unpack.err");
	assertEmptyFile("unpack.out");

	verify_tree(LIMIT_NONE, name);
	assertEqualInt(0, chdir(".."));
}


	assertEmptyFile("unpack.err");
	assertEmptyFile("unpack.out");

	verify_tree(LIMIT_USTAR, "ustar");
	assertEqualInt(0, chdir(".."));
}

DEFINE_TEST(test_copy)

	create_tree(); /* Create sample files in "original" dir. */

	/* Test simple "tar -c | tar -x" pipeline copy. */
	copy_basic("", "default");

	/* Same, but constrain to ustar format. */
	copy_ustar();

	/* Same, but with pax format. */
	copy_basic(" --format pax", "pax");
}




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2009 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012,2014 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2017 Sean Purcell
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2014 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2016 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2018 The FreeBSD Foundation
 * All rights reserved.
 *
 * This software was developed by Arshan Khanifar <arshankhanifar@gmail.com>
 * under sponsorship from the FreeBSD Foundation.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"


	char *p;
#endif

	/* an absolute path to mtree file */
	char *mtree_file = "/METALOG.mtree";
	char *absolute_path = malloc(strlen(testworkdir) + strlen(mtree_file) + 1);
	strcpy(absolute_path, testworkdir);
	strcat(absolute_path, mtree_file );

	/* Create an archive using an mtree file. */
	assertMakeFile(absolute_path, 0777, content);
	assertMakeDir("bar", 0775);




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2010 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2010 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"


	/* Test 3: With -H, some symlinks on command line. */
	assertMakeDir("test3", 0755);
	assertEqualInt(0,
	    systemf("%s -cf test3/archive.tar -H -C in ld1 d1 link2 linkY >test3/c.out 2>test3/c.err", testprog));
	assertChdir("test3");
	assertEqualInt(0,
	    systemf("%s -xf archive.tar >c.out 2>c.err", testprog));

	assertIsReg("link2", umasked(0644));
	assertIsSymlink("linkY", "d1/fileY", 0);
	assertChdir("..");

#if defined(_WIN32) && !defined(__CYGWIN__)
	/* Test 4: With -H, using wildcards with some symlinks on command line. (wildcards are supported only in Windows) */
	assertMakeDir("test4", 0755);
	assertEqualInt(0,
	    systemf("%s -cf test4/archive.tar -H -C in * >test4/c.out 2>test4/c.err", testprog));
	assertChdir("test4");
	assertEqualInt(0,
	    systemf("%s -xf archive.tar >c.out 2>c.err", testprog));
	assertIsDir("ld1", umasked(0755));
	assertIsSymlink("d1/linkX", "fileX", 0);
	assertIsSymlink("d1/link1", "file1", 0);
	assertIsReg("link2", umasked(0644));
	assertIsSymlink("linkY", "d1/fileY", 0);
	assertChdir("..");
#endif
}




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2010 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"


	/* Test 3: With -L, some symlinks on command line. */
	assertMakeDir("test3", 0755);
	assertEqualInt(0,
	    systemf("%s -cf test3/archive.tar -L -C in ld1 d1 link2 linkY >test3/c.out 2>test3/c.err", testprog));
	assertChdir("test3");
	assertEqualInt(0,
	    systemf("%s -xf archive.tar >c.out 2>c.err", testprog));

	assertIsReg("link2", umasked(0644));
	assertIsSymlink("linkY", "d1/fileY", 0);
	assertChdir("..");

#if defined(_WIN32) && !defined(__CYGWIN__)
	/* Test 4: With -L, using wildcards with some symlinks on command line. (wildcards are supported only in Windows) */
	assertMakeDir("test4", 0755);
	assertEqualInt(0,
	    systemf("%s -cf test4/archive.tar -L -C in * >test4/c.out 2>test4/c.err", testprog));
	assertChdir("test4");
	assertEqualInt(0,
	    systemf("%s -xf archive.tar >c.out 2>c.err", testprog));
	assertIsDir("ld1", umasked(0755));
	assertIsReg("d1/link1", umasked(0644));
	assertIsSymlink("d1/linkX", "fileX", 0);
	assertIsReg("link2", umasked(0644));
	assertIsSymlink("linkY", "d1/fileY", 0);
	assertChdir("..");
#endif
}




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2010 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2024 Mostyn Bramley-Moore <mostyn@antipode.se>
 */

#include "test.h"

#include <stdlib.h>
#include <string.h>

#if defined(_WIN32) && !defined(__CYGWIN__)
#define UNLINK _unlink
#else
#define UNLINK unlink
#endif

DEFINE_TEST(test_extract_tar_absolute_paths)
{
	int r;

	// Create an absolute path for a test file inside testworkdir.
	char *entry_suffix = "/tar-noabs";
	size_t entry_suffix_length = strlen(entry_suffix);
	size_t testworkdir_length = strlen(testworkdir);
	size_t temp_absolute_file_name_length = testworkdir_length + entry_suffix_length;
	char *temp_absolute_file_name = calloc(1, temp_absolute_file_name_length + 1); // +1 for null character.
	assertEqualInt(snprintf(temp_absolute_file_name, temp_absolute_file_name_length + 1, "%s%s", testworkdir, entry_suffix),
		temp_absolute_file_name_length);

#if defined(_WIN32) && !defined(__CYGWIN__)
	// I'm unsure how to specify paths with spaces for the test invocation on windows.
	// Adding quotes doesn't seem to work. We should find a way to escape these paths,
	// but for now let's fail in a place that's obviously related to the test setup if
	// testworkdir contains spaces.
	for (char *p = temp_absolute_file_name; *p != '\0'; p++)
	{
		assert(*p != ' ');
		if (*p == ' ') break;
	}
#endif

	// Create the file.
	const char *sample_data = "test file from test_extract_tar_absolute_paths";
	assertMakeFile(temp_absolute_file_name, 0644, sample_data);

	// Create an archive with the test file, using an absolute path.
#if defined(_WIN32) && !defined(__CYGWIN__)
	r = systemf("%s --absolute-paths -cf test.tar %s", testprog, temp_absolute_file_name);
#else
	r = systemf("%s --absolute-paths -cf test.tar \"%s\"", testprog, temp_absolute_file_name);
#endif
	assertEqualInt(r, 0);

	UNLINK(temp_absolute_file_name);

	// Extracting the archive without -P / --absolute-paths should strip leading drive letter or slash
	r = systemf("%s -xf test.tar", testprog);
	assertEqualInt(r, 0);
	assertFileNotExists(temp_absolute_file_name);

	// Check that the mangled path exists.
#if defined(_WIN32) && !defined(__CYGWIN__)
	assertFileExists(temp_absolute_file_name + 3); // Skip the drive letter, colon and slash.
	UNLINK(temp_absolute_file_name + 3);
#else
	assertFileExists(temp_absolute_file_name + 1); // Skip the slash.
	UNLINK(temp_absolute_file_name + 1);
#endif

	// Extracting the archive with -P / --absolute-paths should create the file.
	r = systemf("%s --absolute-paths -xf test.tar", testprog);
	assertEqualInt(r, 0);
	assertFileExists(temp_absolute_file_name);

	// Check that the mangled path wasn't created.
#if defined(_WIN32) && !defined(__CYGWIN__)
	assertFileNotExists(temp_absolute_file_name + 3); // Skip the drive letter, colon and slash.
#else
	assertFileNotExists(temp_absolute_file_name + 1); // Skip the slash.
#endif
}




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2008 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2010 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2010 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2017 Martin Matuska
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2010 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2010 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2019 Martin Matuska
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"


	assertMakeDir("_darcs", 0755);
	assertMakeFile("_darcs/format", 0644, "");
	assertChdir("..");

	assertEqualInt(0, systemf("%s -c -C in -f included.tar .", testprog));
	assertEqualInt(0,
	    systemf("%s -c --exclude-vcs -C in -f excluded.tar .", testprog));




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2017 Martin Matuska
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"


	assertMakeDir("nofflags_fflags", 0755);
	clear_fflags("nofflags_fflags");
	r = systemf("%s -x -C nofflags_fflags --no-same-permissions --fflags -f nofflags.tar >nofflags_fflags.out 2>nofflags_fflags.err", testprog);
	assertEqualInt(r, 0);
	assertUnequalFflags("f", "nofflags_fflags/f");

	/* Extract nofflags with nofflags */




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2010 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2010 Tim Kientzle
 * Copyright (c) 2024 Haelwenn (lanodan) Monnier
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2021 Ryan Libby
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"



DEFINE_TEST(test_option_ignore_zeros_mode_c)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
	// The first command run by systemf below prints this to stderr:
	// bsdtar.exe: a: Can't translate uname '(null)' to UTF-8
	// bsdtar.exe: b: Can't translate uname '(null)' to UTF-8
	skipping("TODO: figure out why this test fails on github workflows with MSVC");
	return;
#endif

	if (make_files())
		return;





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2010 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2010 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2010 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2010 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2010 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2010 Tim Kientzle
 * Copyright (c) 2024 Haelwenn (lanodan) Monnier
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2008 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2020 Martin Matuska
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2010 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2017 Martin Matuska
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"


	/* Extract noxattrs with xattrs */
	assertMakeDir("noxattrs_xattrs", 0755);
	r = systemf("%s -x -C noxattrs_xattrs --no-same-permissions --xattrs -f noxattrs.tar >noxattrs_xattrs.out 2>noxattrs_xattrs.err", testprog);
	assertEqualInt(r, 0);
	readval = getXattr("noxattrs_xattrs/f", testattr, &size);
	assert(readval == NULL);





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2017 Sean Purcell
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2009 Michihiro NAKAJIMA
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2011 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2017 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "bsdtar_platform.h"

	char buff[32];
	char *p;
	ssize_t l;
	int read_fd = 2; /* stderr */

	va_list ap;
	va_start(ap, fmt);

	fprintf(stderr, " (y/N)? ");
	fflush(stderr);

#if defined(_WIN32) && !defined(__CYGWIN__)
	/* To be resilient when stdin is a pipe, bsdtar prefers to read from
	 * stderr.  On Windows, stderr cannot be read. The nearest "piping
	 * resilient" equivalent is reopening the console input handle.
	 */
	read_fd = _open("CONIN$", O_RDONLY);
	if (read_fd < 0) {
	  fprintf(stderr, "Keyboard read failed\n");
	  exit(1);
	}
#endif

	l = read(read_fd, buff, sizeof(buff) - 1);

#if defined(_WIN32) && !defined(__CYGWIN__)
	_close(read_fd);
#endif

	if (l < 0) {
	  fprintf(stderr, "Keyboard read failed\n");
	  exit(1);




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "bsdtar_platform.h"

#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#if HAVE_SYS_XATTR_H
#include <sys/xattr.h>
#elif HAVE_ATTR_XATTR_H
#include <attr/xattr.h>
#endif
#ifdef HAVE_ERRNO_H


		while (entry != NULL) {
			write_file(bsdtar, a, entry);
			if (entry != spare_entry) {
				archive_entry_free(entry);
			}
			entry = spare_entry;
			spare_entry = NULL;
		}

			safe_fprintf(stderr, "a ");
			list_item_verbose(bsdtar, stderr, entry);
			lafe_warnc(0, ": %s", archive_error_string(a));
		} else {
			lafe_warnc(0, "%s: %s",
			    archive_entry_pathname(entry),
			    archive_error_string(a));
		}
			fprintf(stderr, ": %s", archive_error_string(a));
	}

	if (e == ARCHIVE_FATAL)

Lines 48-53 Link Here

(-)b/contrib/libarchive/test_utils/test_common.h (-1 / +4 lines)
48	#endif	48	#endif
49		49
50	#include <sys/types.h> /* Windows requires this before sys/stat.h */	50	#include <sys/types.h> /* Windows requires this before sys/stat.h */
		51	#if !HAVE_SUSECONDS_T
		52	#define suseconds_t long
		53	#endif
51	#include <sys/stat.h>	54	#include <sys/stat.h>
52		55
53	#if HAVE_DIRENT_H	56	#if HAVE_DIRENT_H
Lines 313-319 int assertion_non_empty_file(const char , int, const char ); Link Here
313	int assertion_set_nodump(const char , int, const char );	316	int assertion_set_nodump(const char , int, const char );
314	int assertion_text_file_contents(const char , int, const char buff, const char *f);	317	int assertion_text_file_contents(const char , int, const char buff, const char *f);
315	int assertion_umask(const char *, int, int);	318	int assertion_umask(const char *, int, int);
316	int assertion_utimes(const char , int, const char , long, long, long, long );	319	int assertion_utimes(const char , int, const char , time_t, suseconds_t, time_t, suseconds_t);
317	int assertion_version(const char, int, const char , const char *);	320	int assertion_version(const char, int, const char , const char *);
318		321
319	void skipping_setup(const char *, int);	322	void skipping_setup(const char *, int);

Lines 85-90 Link Here

(-)b/contrib/libarchive/test_utils/test_main.c (-42 / +59 lines)
85	#include <membership.h>	85	#include <membership.h>
86	#endif	86	#endif
87		87
		88	#ifndef nitems
		89	#define nitems(arr) (sizeof(arr) / sizeof((arr)[0]))
		90	#endif
		91
88	/*	92	/*
89	*	93	*
90	* Windows support routines	94	* Windows support routines
Lines 121-126 Link Here
121	#define access _access	125	#define access _access
122	#undef chdir	126	#undef chdir
123	#define chdir _chdir	127	#define chdir _chdir
		128	#undef chmod
		129	#define chmod _chmod
124	#endif	130	#endif
125	#ifndef fileno	131	#ifndef fileno
126	#define fileno _fileno	132	#define fileno _fileno
Lines 217-223 my_CreateSymbolicLinkA(const char linkname, const char target, Link Here
217	static BOOLEAN (WINAPI *f)(LPCSTR, LPCSTR, DWORD);	223	static BOOLEAN (WINAPI *f)(LPCSTR, LPCSTR, DWORD);
218	DWORD attrs;	224	DWORD attrs;
219	static int set;	225	static int set;
220	int ret, tmpflags, llen, tlen;	226	int ret, tmpflags;
		227	size_t llen, tlen;
221	int flags = 0;	228	int flags = 0;
222	char src, tgt, *p;	229	char src, tgt, *p;
223	if (!set) {	230	if (!set) {
Lines 233-242 my_CreateSymbolicLinkA(const char linkname, const char target, Link Here
233	if (tlen == 0 \|\| llen == 0)	240	if (tlen == 0 \|\| llen == 0)
234	return (0);	241	return (0);
235		242
236	tgt = malloc((tlen + 1) * sizeof(char));	243	tgt = malloc(tlen + 1);
237	if (tgt == NULL)	244	if (tgt == NULL)
238	return (0);	245	return (0);
239	src = malloc((llen + 1) * sizeof(char));	246	src = malloc(llen + 1);
240	if (src == NULL) {	247	if (src == NULL) {
241	free(tgt);	248	free(tgt);
242	return (0);	249	return (0);
Lines 1237-1252 assertion_file_contains_lines_any_order(const char *file, int line, Link Here
1237	}	1244	}
1238	expected_count = i;	1245	expected_count = i;
1239	if (expected_count) {	1246	if (expected_count) {
1240	expected = malloc(sizeof(char ) expected_count);	1247	expected = calloc(expected_count, sizeof(*expected));
1241	if (expected == NULL) {	1248	if (expected == NULL) {
1242	failure_start(pathname, line, "Can't allocate memory");	1249	failure_start(pathname, line, "Can't allocate memory");
1243	failure_finish(NULL);	1250	failure_finish(NULL);
1244	free(expected);	1251	goto cleanup;
1245	free(buff);
1246	return (0);
1247	}	1252	}
1248	for (i = 0; lines[i] != NULL; ++i) {	1253	for (i = 0; lines[i] != NULL; ++i) {
1249	expected[i] = strdup(lines[i]);	1254	expected[i] = strdup(lines[i]);
		1255	if (expected[i] == NULL) {
		1256	failure_start(pathname, line, "Can't allocate memory");
		1257	failure_finish(NULL);
		1258	goto cleanup;
		1259	}
1250	}	1260	}
1251	}	1261	}
1252		1262
Lines 1264-1272 assertion_file_contains_lines_any_order(const char *file, int line, Link Here
1264	if (actual == NULL) {	1274	if (actual == NULL) {
1265	failure_start(pathname, line, "Can't allocate memory");	1275	failure_start(pathname, line, "Can't allocate memory");
1266	failure_finish(NULL);	1276	failure_finish(NULL);
1267	free(expected);	1277	goto cleanup;
1268	free(buff);
1269	return (0);
1270	}	1278	}
1271	for (j = 0, p = buff; p < buff + buff_size;	1279	for (j = 0, p = buff; p < buff + buff_size;
1272	p += 1 + strlen(p)) {	1280	p += 1 + strlen(p)) {
Lines 1279-1286 assertion_file_contains_lines_any_order(const char *file, int line, Link Here
1279		1287
1280	/* Erase matching lines from both lists */	1288	/* Erase matching lines from both lists */
1281	for (i = 0; i < expected_count; ++i) {	1289	for (i = 0; i < expected_count; ++i) {
1282	if (expected[i] == NULL)
1283	continue;
1284	for (j = 0; j < actual_count; ++j) {	1290	for (j = 0; j < actual_count; ++j) {
1285	if (actual[j] == NULL)	1291	if (actual[j] == NULL)
1286	continue;	1292	continue;
Lines 1303-1311 assertion_file_contains_lines_any_order(const char *file, int line, Link Here
1303	++actual_failure;	1309	++actual_failure;
1304	}	1310	}
1305	if (expected_failure == 0 && actual_failure == 0) {	1311	if (expected_failure == 0 && actual_failure == 0) {
1306	free(buff);
1307	free(expected);
1308	free(actual);	1312	free(actual);
		1313	free(expected);
		1314	free(buff);
1309	return (1);	1315	return (1);
1310	}	1316	}
1311	failure_start(file, line, "File doesn't match: %s", pathname);	1317	failure_start(file, line, "File doesn't match: %s", pathname);
Lines 1313-1318 assertion_file_contains_lines_any_order(const char *file, int line, Link Here
1313	if (expected[i] != NULL) {	1319	if (expected[i] != NULL) {
1314	logprintf(" Expected but not present: %s\n", expected[i]);	1320	logprintf(" Expected but not present: %s\n", expected[i]);
1315	free(expected[i]);	1321	free(expected[i]);
		1322	expected[i] = NULL;
1316	}	1323	}
1317	}	1324	}
1318	for (j = 0; j < actual_count; ++j) {	1325	for (j = 0; j < actual_count; ++j) {
Lines 1320-1328 assertion_file_contains_lines_any_order(const char *file, int line, Link Here
1320	logprintf(" Present but not expected: %s\n", actual[j]);	1327	logprintf(" Present but not expected: %s\n", actual[j]);
1321	}	1328	}
1322	failure_finish(NULL);	1329	failure_finish(NULL);
1323	free(buff);	1330	cleanup:
1324	free(expected);
1325	free(actual);	1331	free(actual);
		1332	if (expected != NULL) {
		1333	for (i = 0; i < expected_count; ++i)
		1334	if (expected[i] != NULL)
		1335	free(expected[i]);
		1336	free(expected);
		1337	}
		1338	free(buff);
1326	return (0);	1339	return (0);
1327	}	1340	}
1328		1341
Lines 1766-1781 is_symlink(const char *file, int line, Link Here
1766	FILE_FLAG_OPEN_REPARSE_POINT;	1779	FILE_FLAG_OPEN_REPARSE_POINT;
1767		1780
1768	/* Replace slashes with backslashes in pathname */	1781	/* Replace slashes with backslashes in pathname */
1769	pn = malloc((strlen(pathname) + 1) * sizeof(char));	1782	pn = malloc(strlen(pathname) + 1);
1770	p = pathname;	1783	if (pn == NULL) {
1771	s = pn;	1784	failure_start(file, line, "Can't allocate memory");
1772	while(*p != '\0') {	1785	failure_finish(NULL);
1773	if(*p == '/')	1786	return (0);
		1787	}
		1788	for (p = pathname, s = pn; *p != '\0'; p++, s++) {
		1789	if (*p == '/')
1774	*s = '\\';	1790	*s = '\\';
1775	else	1791	else
1776	s = p;	1792	s = p;
1777	p++;
1778	s++;
1779	}	1793	}
1780	*s = '\0';	1794	*s = '\0';
1781		1795
Lines 2083-2090 assertion_umask(const char *file, int line, int mask) Link Here
2083		2097
2084	/* Set times, report failures. */	2098	/* Set times, report failures. */
2085	int	2099	int
2086	assertion_utimes(const char *file, int line,	2100	assertion_utimes(const char file, int line, const char pathname,
2087	const char *pathname, long at, long at_nsec, long mt, long mt_nsec)	2101	time_t at, suseconds_t at_nsec, time_t mt, suseconds_t mt_nsec)
2088	{	2102	{
2089	int r;	2103	int r;
2090		2104
Lines 2950-2956 setTestAcl(const char *path) Link Here
2950	acl_permset_t permset;	2964	acl_permset_t permset;
2951	const uid_t uid = 1;	2965	const uid_t uid = 1;
2952	uuid_t uuid;	2966	uuid_t uuid;
2953	int i;
2954	const acl_perm_t acl_perms[] = {	2967	const acl_perm_t acl_perms[] = {
2955	ACL_READ_DATA,	2968	ACL_READ_DATA,
2956	ACL_WRITE_DATA,	2969	ACL_WRITE_DATA,
Lines 2992-2998 setTestAcl(const char *path) Link Here
2992	failure("acl_get_permset() error: %s", strerror(errno));	3005	failure("acl_get_permset() error: %s", strerror(errno));
2993	if (assertEqualInt(r, 0) == 0)	3006	if (assertEqualInt(r, 0) == 0)
2994	goto testacl_free;	3007	goto testacl_free;
2995	for (i = 0; i < (int)(sizeof(acl_perms) / sizeof(acl_perms[0])); i++) {	3008	for (size_t i = 0; i < nitems(acl_perms); i++) {
2996	r = acl_add_perm(permset, acl_perms[i]);	3009	r = acl_add_perm(permset, acl_perms[i]);
2997	failure("acl_add_perm() error: %s", strerror(errno));	3010	failure("acl_add_perm() error: %s", strerror(errno));
2998	if (assertEqualInt(r, 0) == 0)	3011	if (assertEqualInt(r, 0) == 0)
Lines 3642-3648 test_run(int i, const char *tmpdir) Link Here
3642	static void	3655	static void
3643	usage(const char *program)	3656	usage(const char *program)
3644	{	3657	{
3645	static const int limit = sizeof(tests) / sizeof(tests[0]);	3658	static const int limit = nitems(tests);
3646	int i;	3659	int i;
3647		3660
3648	printf("Usage: %s [options] <test> <test> ...\n", program);	3661	printf("Usage: %s [options] <test> <test> ...\n", program);
Lines 3874-3885 get_test_set(int test_set, int limit, const char test) Link Here
3874	int	3887	int
3875	main(int argc, char **argv)	3888	main(int argc, char **argv)
3876	{	3889	{
3877	static const int limit = sizeof(tests) / sizeof(tests[0]);	3890	static const int limit = nitems(tests);
3878	int test_set[sizeof(tests) / sizeof(tests[0])];	3891	int test_set[nitems(tests)];
3879	int i = 0, j = 0, tests_run = 0, tests_failed = 0, option;	3892	int i = 0, j = 0, tests_run = 0, tests_failed = 0, option;
3880	int testprogdir_len;	3893	size_t testprogdir_len;
		3894	size_t tmplen;
3881	#ifdef PROGRAM	3895	#ifdef PROGRAM
3882	int tmp2_len;	3896	size_t tmp2_len;
3883	#endif	3897	#endif
3884	time_t now;	3898	time_t now;
3885	struct tm *tmptr;	3899	struct tm *tmptr;
Lines 3922-3928 main(int argc, char **argv) Link Here
3922	*/	3936	*/
3923	progname = p = argv[0];	3937	progname = p = argv[0];
3924	testprogdir_len = strlen(progname) + 1;	3938	testprogdir_len = strlen(progname) + 1;
3925	if ((testprogdir = (char *)malloc(testprogdir_len)) == NULL)	3939	if ((testprogdir = malloc(testprogdir_len)) == NULL)
3926	{	3940	{
3927	fprintf(stderr, "ERROR: Out of memory.");	3941	fprintf(stderr, "ERROR: Out of memory.");
3928	exit(1);	3942	exit(1);
Lines 3950-3956 main(int argc, char **argv) Link Here
3950	#endif	3964	#endif
3951	{	3965	{
3952	/* Fixup path for relative directories. */	3966	/* Fixup path for relative directories. */
3953	if ((testprogdir = (char *)realloc(testprogdir,	3967	if ((testprogdir = realloc(testprogdir,
3954	strlen(pwd) + 1 + strlen(testprogdir) + 1)) == NULL)	3968	strlen(pwd) + 1 + strlen(testprogdir) + 1)) == NULL)
3955	{	3969	{
3956	fprintf(stderr, "ERROR: Out of memory.");	3970	fprintf(stderr, "ERROR: Out of memory.");
Lines 3977-3982 main(int argc, char **argv) Link Here
3977	tmp = getenv("TEMPDIR");	3991	tmp = getenv("TEMPDIR");
3978	else	3992	else
3979	tmp = "/tmp";	3993	tmp = "/tmp";
		3994	tmplen = strlen(tmp);
		3995	while (tmplen > 0 && tmp[tmplen - 1] == '/')
		3996	tmplen--;
3980		3997
3981	/* Allow -d to be controlled through the environment. */	3998	/* Allow -d to be controlled through the environment. */
3982	if (getenv(ENVBASE "_DEBUG") != NULL)	3999	if (getenv(ENVBASE "_DEBUG") != NULL)
Lines 4070-4076 main(int argc, char **argv) Link Here
4070	if (testprogfile == NULL)	4087	if (testprogfile == NULL)
4071	{	4088	{
4072	tmp2_len = strlen(testprogdir) + 1 + strlen(PROGRAM) + 1;	4089	tmp2_len = strlen(testprogdir) + 1 + strlen(PROGRAM) + 1;
4073	if ((tmp2 = (char *)malloc(tmp2_len)) == NULL)	4090	if ((tmp2 = malloc(tmp2_len)) == NULL)
4074	{	4091	{
4075	fprintf(stderr, "ERROR: Out of memory.");	4092	fprintf(stderr, "ERROR: Out of memory.");
4076	exit(1);	4093	exit(1);
Lines 4083-4089 main(int argc, char **argv) Link Here
4083		4100
4084	{	4101	{
4085	char *testprg;	4102	char *testprg;
4086	int testprg_len;	4103	size_t testprg_len;
4087	#if defined(_WIN32) && !defined(__CYGWIN__)	4104	#if defined(_WIN32) && !defined(__CYGWIN__)
4088	/* Command.com sometimes rejects '/' separators. */	4105	/* Command.com sometimes rejects '/' separators. */
4089	testprg = strdup(testprogfile);	4106	testprg = strdup(testprogfile);
Lines 4129-4144 main(int argc, char **argv) Link Here
4129	#endif	4146	#endif
4130	strftime(tmpdir_timestamp, sizeof(tmpdir_timestamp),	4147	strftime(tmpdir_timestamp, sizeof(tmpdir_timestamp),
4131	"%Y-%m-%dT%H.%M.%S", tmptr);	4148	"%Y-%m-%dT%H.%M.%S", tmptr);
4132	if ((strlen(tmp) + 1 + strlen(progname) + 1 +	4149	if (tmplen + 1 + strlen(progname) + 1 +
4133	strlen(tmpdir_timestamp) + 1 + 3) >	4150	strlen(tmpdir_timestamp) + 1 + 3 >=
4134	(sizeof(tmpdir) / sizeof(char))) {	4151	nitems(tmpdir)) {
4135	fprintf(stderr,	4152	fprintf(stderr,
4136	"ERROR: Temp directory pathname too long\n");	4153	"ERROR: Temp directory pathname too long\n");
4137	exit(1);	4154	exit(1);
4138	}	4155	}
4139	snprintf(tmpdir, sizeof(tmpdir), "%s/%s.%s-%03d", tmp,	4156	snprintf(tmpdir, sizeof(tmpdir), "%.*s/%s.%s-%03d",
4140	progname, tmpdir_timestamp, i);	4157	(int)tmplen, tmp, progname, tmpdir_timestamp, i);
4141	if (assertMakeDir(tmpdir,0755))	4158	if (assertMakeDir(tmpdir, 0755))
4142	break;	4159	break;
4143	if (i >= 999) {	4160	if (i >= 999) {
4144	fprintf(stderr,	4161	fprintf(stderr,




.\"-
.\" SPDX-License-Identifier: BSD-2-Clause
.\"
.\" Copyright (c) 2007-2008 Dag-Erling Smørgrav
.\" All rights reserved.
.\"
.\" Redistribution and use in source and binary forms, with or without
.\" modification, are permitted provided that the following conditions
.\" are met:
.\" 1. Redistributions of source code must retain the above copyright
.\"    notice, this list of conditions and the following disclaimer.
.\" 2. Redistributions in binary form must reproduce the above copyright
.\"    notice, this list of conditions and the following disclaimer in the
.\"    documentation and/or other materials provided with the distribution.
.\"
.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
.\" SUCH DAMAGE.
.\"
.Dd June 27, 2023
.Dt BSDUNZIP 1
.Os

be repeated.
For example, to extract a "-a.jpg" from "-b.zip" with overwrite, one
would need to invoke
.Dl bsdunzip -o -- -a.jpg -- -b.zip




 * Copyright (c) 2009, 2010 Joerg Sonnenberger <joerg@NetBSD.org>
 * Copyright (c) 2007-2008 Dag-Erling Smørgrav
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * This file would be much shorter if we didn't care about command-line
 * compatibility with Info-ZIP's UnZip, which requires us to duplicate
 * parts of libarchive in order to gain more detailed control of its
 * behaviour for the purpose of implementing the -n, -o, -L and -a
 * options.
 */

#include "bsdunzip_platform.h"

#ifdef HAVE_SYS_QUEUE_H
#include <sys/queue.h>
#else
#include "la_queue.h"
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif

		fprintf(stderr,
		    "replace %s? [y]es, [n]o, [A]ll, [N]one, [r]ename: ",
		    *path);
		if (fgets(buf, sizeof(buf), stdin) == NULL)
			goto stdin_err;
			printf("NULL\n(EOF or read error, "
			    "treating as \"[N]one\"...)\n");
			n_opt = 1;
			return -1;
		}
		switch (*buf) {
		case 'A':
			o_opt = 1;

			*path = NULL;
			alen = 0;
			len = getline(path, &alen, stdin);
			if (len < 1)
				goto stdin_err;
			if ((*path)[len - 1] == '\n')
				(*path)[len - 1] = '\0';
			return 0;

			break;
		}
	}
stdin_err:
	clearerr(stdin);
	printf("NULL\n(EOF or read error, "
		"treating as \"[N]one\"...)\n");
	n_opt = 1;
	return -1;
}

/*




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023, Martin Matuska
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef BSDUNZIP_H_INCLUDED




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*

#define __LA_NORETURN       __attribute__((__noreturn__))
#elif defined(_MSC_VER)
#define __LA_NORETURN __declspec(noreturn)
#else
#define __LA_NORETURN
#endif





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2008 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*




/*	$NetBSD: getline.c,v 1.2 2014/09/16 17:23:50 christos Exp $	*/

/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2011 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Christos Zoulas.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "bsdunzip_platform.h"




/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2017 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/* Every test program should #include "test.h" as the first thing. */




/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2007 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Aaron Lindros
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"


DEFINE_TEST(test_I)
{
	const char *reffile = "test_I.zip";
#if !defined(_WIN32) || defined(__CYGWIN__)
	const char *envstr = "env LANG=en_US.UTF-8 LC_ALL=en_US.UTF-8 "
	    "LC_CTYPE=en_US.UTF-8";
#else
	const char *envstr = "";
#endif
	int r;

#if HAVE_SETLOCALE

	skipping("setlocale() not available on this system.");
#endif

	lang = getenv("LANG");
	setenv("LANG", "en_US.UTF-8", 1);
	extract_reference_file(reffile);
	r = systemf("%s %s -I UTF-8 %s >test.out 2>test.err", envstr, testprog,
	    reffile);
	assertEqualInt(0, r);
	assertNonEmptyFile("test.out");
	assertEmptyFile("test.err");

	assertTextFileContents("Hello, World!\n", "Γειά σου Κόσμε.txt");

	if (lang == NULL)
		unsetenv("LANG");
	else
		setenv("LANG", lang, 1);
}




/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"

/* Test P arg - password protected */
DEFINE_TEST(test_P_encryption)
{
	const char *reffile = "test_encrypted.zip";
	int r;




/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"

/* Test n arg - don't overwrite existing files */
DEFINE_TEST(test_n)
{
	const char *reffile = "test_basic.zip";




/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"

/* Test non existent file */
DEFINE_TEST(test_not_exist)
{
	int r;




/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"

/* Test o arg - overwrite existing files */
DEFINE_TEST(test_o)
{
	const char *reffile = "test_basic.zip";




/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003-2017 Tim Kientzle
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"





/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Adrian Vovk
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"






.PATH: ${_LIBARCHIVEDIR}/libarchive/test
TESTS_SRCS= \
	test_7zip_filename_encoding.c		\
	test_acl_nfs4.c				\
	test_acl_pax.c				\
	test_acl_platform_nfs4.c		\
	test_acl_platform_posix1e.c		\
	test_acl_posix1e.c			\
	test_acl_text.c				\
	test_ar_mode.c				\
	test_archive_api_feature.c		\
	test_archive_clear_error.c		\
	test_archive_cmdline.c			\

	test_archive_match_owner.c		\
	test_archive_match_path.c		\
	test_archive_pathmatch.c		\
	test_archive_read.c			\
	test_archive_read_add_passphrase.c	\
	test_archive_read_close_twice.c		\
	test_archive_read_close_twice_open_fd.c	\

	test_read_file_nonexistent.c		\
	test_read_filter_compress.c		\
	test_read_filter_grzip.c		\
	test_read_filter_gzip_recursive.c	\
	test_read_filter_lrzip.c		\
	test_read_filter_lzop.c			\
	test_read_filter_lzop_multiple_parts.c	\

	test_read_format_gtar_lzma.c		\
	test_read_format_gtar_sparse.c		\
	test_read_format_gtar_sparse_skip_entry.c \
	test_read_format_huge_rpm.c		\
	test_read_format_iso_Z.c		\
	test_read_format_iso_multi_extent.c	\
	test_read_format_iso_xorriso.c		\

	test_read_format_pax_bz2.c		\
	test_read_format_rar.c			\
	test_read_format_rar5.c			\
	test_read_format_rar_encryption.c	\
	test_read_format_rar_encryption_data.c	\
	test_read_format_rar_encryption_header.c	\
	test_read_format_rar_encryption_partially.c	\

	test_read_format_tar_empty_with_gnulabel.c	\
	test_read_format_tar_filename.c		\
	test_read_format_tar_invalid_pax_size.c \
	test_read_format_tar_pax_large_attr.c	\
	test_read_format_tbz.c			\
	test_read_format_tgz.c			\
	test_read_format_tlz.c			\

	test_write_disk_no_hfs_compression.c	\
	test_write_disk_perms.c			\
	test_write_disk_secure.c		\
	test_write_disk_secure_noabsolutepaths.c	\
	test_write_disk_secure744.c		\
	test_write_disk_secure745.c		\
	test_write_disk_secure746.c		\

	test_write_format_zip_zip64.c		\
	test_write_format_zip64_stream.c	\
	test_write_format_zip_stream.c		\
	test_write_format_zip_windows_path.c	\
	test_write_open_memory.c		\
	test_write_read_format_zip.c		\
	test_xattr_platform.c			\

${PACKAGE}FILES+=	test_rar_multivolume_uncompressed_files.part09.rar.uu
${PACKAGE}FILES+=	test_rar_multivolume_uncompressed_files.part10.rar.uu
${PACKAGE}FILES+=	test_read_filter_grzip.tar.grz.uu
${PACKAGE}FILES+=	test_read_filter_gzip_recursive.gz.uu
${PACKAGE}FILES+=	test_read_filter_lrzip.tar.lrz.uu
${PACKAGE}FILES+=	test_read_filter_lzop.tar.lzo.uu
${PACKAGE}FILES+=	test_read_filter_lzop_multiple_parts.tar.lzo.uu

${PACKAGE}FILES+=	test_read_format_7zip_encryption.7z.uu
${PACKAGE}FILES+=	test_read_format_7zip_encryption_header.7z.uu
${PACKAGE}FILES+=	test_read_format_7zip_encryption_partially.7z.uu
${PACKAGE}FILES+=	test_read_format_7zip_extract_second.7z.uu
${PACKAGE}FILES+=	test_read_format_7zip_lzma1.7z.uu
${PACKAGE}FILES+=	test_read_format_7zip_lzma1_2.7z.uu
${PACKAGE}FILES+=	test_read_format_7zip_lzma1_lzma2.7z.uu

${PACKAGE}FILES+=	test_read_format_gtar_sparse_1_17_posix10.tar.uu
${PACKAGE}FILES+=	test_read_format_gtar_sparse_1_17_posix10_modified.tar.uu
${PACKAGE}FILES+=	test_read_format_gtar_sparse_skip_entry.tar.Z.uu
${PACKAGE}FILES+=	test_read_format_huge_rpm.rpm.uu
${PACKAGE}FILES+=	test_read_format_iso.iso.Z.uu
${PACKAGE}FILES+=	test_read_format_iso_2.iso.Z.uu
${PACKAGE}FILES+=	test_read_format_iso_3.iso.Z.uu
${PACKAGE}FILES+=	test_read_format_iso_joliet.iso.Z.uu
${PACKAGE}FILES+=	test_read_format_iso_joliet_by_nero.iso.Z.uu
${PACKAGE}FILES+=	test_read_format_iso_joliet_long.iso.Z.uu

${PACKAGE}FILES+=	test_read_format_rar_subblock.rar.uu
${PACKAGE}FILES+=	test_read_format_rar_unicode.rar.uu
${PACKAGE}FILES+=	test_read_format_rar_windows.rar.uu
${PACKAGE}FILES+=	test_read_format_rar4_encrypted.rar.uu
${PACKAGE}FILES+=	test_read_format_rar4_encrypted_filenames.rar.uu
${PACKAGE}FILES+=	test_read_format_rar4_solid_encrypted.rar.uu
${PACKAGE}FILES+=	test_read_format_rar4_solid_encrypted_filenames.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_arm.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_arm_filter_on_window_boundary.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_bad_window_sz_in_mltarc_file.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_data_ready_pointer_leak.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_blake2.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_block_size_is_too_small.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_compressed.rar.uu

${PACKAGE}FILES+=	test_read_format_rar5_different_window_size.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_different_winsize_on_merge.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_distance_overflow.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_encrypted.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_encrypted_filenames.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_solid_encrypted.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_solid_encrypted_filenames.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_extra_field_version.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_fileattr.rar.uu
${PACKAGE}FILES+=	test_read_format_rar5_hardlink.rar.uu

${PACKAGE}FILES+=	test_read_format_tar_empty_pax.tar.Z.uu
${PACKAGE}FILES+=	test_read_format_tar_filename_koi8r.tar.Z.uu
${PACKAGE}FILES+=	test_read_format_tar_invalid_pax_size.tar.uu
${PACKAGE}FILES+=	test_read_format_tar_pax_large_attr.tar.Z.uu
${PACKAGE}FILES+=	test_read_format_ustar_filename_cp866.tar.Z.uu
${PACKAGE}FILES+=	test_read_format_ustar_filename_eucjp.tar.Z.uu
${PACKAGE}FILES+=	test_read_format_ustar_filename_koi8r.tar.Z.uu
${PACKAGE}FILES+=	test_read_format_warc.warc.uu
${PACKAGE}FILES+=	test_read_format_xar_doublelink.xar.uu
${PACKAGE}FILES+=	test_read_format_xar_duplicate_filename_node.xar.uu
${PACKAGE}FILES+=	test_read_format_zip.zip.uu
${PACKAGE}FILES+=	test_read_format_zip_7075_utf8_paths.zip.uu
${PACKAGE}FILES+=	test_read_format_zip_7z_deflate.zip.uu

Lines 33-38 TESTS_SRCS= \ Link Here

(-)b/usr.bin/cpio/tests/Makefile (+1 lines)
33	test_0.c \	33	test_0.c \
34	test_basic.c \	34	test_basic.c \
35	test_cmdline.c \	35	test_cmdline.c \
		36	test_extract_cpio_absolute_paths.c \
36	test_extract_cpio_Z.c \	37	test_extract_cpio_Z.c \
37	test_extract_cpio_bz2.c \	38	test_extract_cpio_bz2.c \
38	test_extract_cpio_grz.c \	39	test_extract_cpio_grz.c \

Lines 47-52 TESTS_SRCS= \ Link Here

(-)b/usr.bin/tar/tests/Makefile (+1 lines)
47	test_option_H_upper.c \	47	test_option_H_upper.c \
48	test_option_L_upper.c \	48	test_option_L_upper.c \
49	test_option_O_upper.c \	49	test_option_O_upper.c \
		50	test_option_P.c \
50	test_option_T_upper.c \	51	test_option_T_upper.c \
51	test_option_U_upper.c \	52	test_option_U_upper.c \
52	test_option_X_upper.c \	53	test_option_X_upper.c \

Return to bug 282047

Lines 1-26 Link Here

(-)b/contrib/libarchive/cat/bsdcat.1 (-22 / +4 lines)
1	.\" Copyright (c) 2011-2014, Mike Kazantsev
2	.\" All rights reserved.
3	.\"	1	.\"
4	.\" Redistribution and use in source and binary forms, with or without	2	.\" SPDX-License-Identifier: BSD-2-Clause
5	.\" modification, are permitted provided that the following conditions
6	.\" are met:
7	.\" 1. Redistributions of source code must retain the above copyright
8	.\" notice, this list of conditions and the following disclaimer.
9	.\" 2. Redistributions in binary form must reproduce the above copyright
10	.\" notice, this list of conditions and the following disclaimer in the
11	.\" documentation and/or other materials provided with the distribution.
12	.\"	3	.\"
13	.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND	4	.\" Copyright (c) 2011-2014, Mike Kazantsev
14	.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE	5	.\" All rights reserved.
15	.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16	.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17	.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18	.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19	.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20	.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21	.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22	.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23	.\" SUCH DAMAGE.
24	.\"	6	.\"
25	.Dd March 1, 2014	7	.Dd March 1, 2014
26	.Dt BSDCAT 1	8	.Dt BSDCAT 1
Lines 39-45 expands files to standard output. Link Here
39	.Nm	21	.Nm
40	typically takes a filename as an argument or reads standard input when used in a	22	typically takes a filename as an argument or reads standard input when used in a
41	pipe.	23	pipe.
42	In both cases decompressed data it written to standard output.	24	In both cases decompressed data is written to standard output.
43	.Sh EXAMPLES	25	.Sh EXAMPLES
44	To decompress a file:	26	To decompress a file:
45	.Pp	27	.Pp

Lines 1-26 Link Here

(-)b/contrib/libarchive/cat/bsdcat.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2011-2014, Mike Kazantsev	4	* Copyright (c) 2011-2014, Mike Kazantsev
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25		7
26	#include "bsdcat_platform.h"	8	#include "bsdcat_platform.h"

Lines 1-26 Link Here

(-)b/contrib/libarchive/cat/bsdcat.h (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2014, Mike Kazantsev	4	* Copyright (c) 2014, Mike Kazantsev
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25		7
26	#ifndef BSDCAT_H_INCLUDED	8	#ifndef BSDCAT_H_INCLUDED

Lines 1-26 Link Here

(-)b/contrib/libarchive/cat/bsdcat_platform.h (-21 / +3 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2007 Tim Kientzle	4	* Copyright (c) 2003-2007 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25		7
26	/*	8	/*
Lines 58-64 Link Here
58	#define __LA_NORETURN __attribute__((__noreturn__))	40	#define __LA_NORETURN __attribute__((__noreturn__))
59	#elif defined(_MSC_VER)	41	#elif defined(_MSC_VER)
60	#define __LA_NORETURN __declspec(noreturn)	42	#define __LA_NORETURN __declspec(noreturn)
61	#else	43	#else
62	#define __LA_NORETURN	44	#define __LA_NORETURN
63	#endif	45	#endif
64		46

Lines 1-26 Link Here

(-)b/contrib/libarchive/cat/cmdline.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2008 Tim Kientzle	4	* Copyright (c) 2003-2008 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25		7
26	/*	8	/*

Lines 1-26 Link Here

(-)b/contrib/libarchive/cat/test/test.h (-20 / +2 lines)
1	/*	1	/*
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2006 Tim Kientzle	4	* Copyright (c) 2003-2006 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25		7
26	/* Every test program should #include "test.h" as the first thing. */	8	/* Every test program should #include "test.h" as the first thing. */

Lines 1-26 Link Here

(-)b/contrib/libarchive/cat/test/test_0.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2007 Tim Kientzle	4	* Copyright (c) 2003-2007 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8

Lines 1-26 Link Here

(-)b/contrib/libarchive/cat/test/test_empty_gz.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2014 Sebastian Freundt	4	* Copyright (c) 2014 Sebastian Freundt
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8

Lines 1-26 Link Here

(-)b/contrib/libarchive/cat/test/test_empty_zstd.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2017 Sean Purcell	4	* Copyright (c) 2017 Sean Purcell
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8

Lines 1-26 Link Here

(-)b/contrib/libarchive/cat/test/test_error.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2014 Mike Kazantsev	4	* Copyright (c) 2014 Mike Kazantsev
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8

Lines 1-26 Link Here

(-)b/contrib/libarchive/cat/test/test_expand_Z.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2014 Mike Kazantsev	4	* Copyright (c) 2014 Mike Kazantsev
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8

Lines 1-26 Link Here

(-)b/contrib/libarchive/cat/test/test_help.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2007 Tim Kientzle	4	* Copyright (c) 2003-2007 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8

Lines 1-26 Link Here

(-)b/contrib/libarchive/cat/test/test_stdin.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2017 Sean Purcell	4	* Copyright (c) 2017 Sean Purcell
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8

Lines 1-26 Link Here

(-)b/contrib/libarchive/cat/test/test_version.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2017 Tim Kientzle	4	* Copyright (c) 2003-2017 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8

Lines 1-26 Link Here

(-)b/contrib/libarchive/cpio/bsdcpio.1 (-21 / +3 lines)
1	.\" Copyright (c) 2003-2007 Tim Kientzle
2	.\" All rights reserved.
3	.\"	1	.\"
4	.\" Redistribution and use in source and binary forms, with or without	2	.\" SPDX-License-Identifier: BSD-2-Clause
5	.\" modification, are permitted provided that the following conditions
6	.\" are met:
7	.\" 1. Redistributions of source code must retain the above copyright
8	.\" notice, this list of conditions and the following disclaimer.
9	.\" 2. Redistributions in binary form must reproduce the above copyright
10	.\" notice, this list of conditions and the following disclaimer in the
11	.\" documentation and/or other materials provided with the distribution.
12	.\"	3	.\"
13	.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND	4	.\" Copyright (c) 2003-2007 Tim Kientzle
14	.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE	5	.\" All rights reserved.
15	.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16	.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17	.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18	.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19	.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20	.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21	.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22	.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23	.\" SUCH DAMAGE.
24	.\"	6	.\"
25	.Dd September 16, 2014	7	.Dd September 16, 2014
26	.Dt CPIO 1	8	.Dt CPIO 1

Lines 1-27 Link Here

(-)b/contrib/libarchive/cpio/cmdline.c (-37 / +39 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2007 Tim Kientzle	4	* Copyright (c) 2003-2007 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer
10	* in this position and unchanged.
11	* 2. Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
16	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
19	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25	*/	6	*/
26		7
27		8
Lines 308-324 cpio_getopt(struct cpio *cpio) Link Here
308	* Returns NULL if no error, otherwise returns error string for display.	289	* Returns NULL if no error, otherwise returns error string for display.
309	*	290	*
310	*/	291	*/
311	const char *	292	int
312	owner_parse(const char spec, int uid, int *gid)	293	owner_parse(const char spec, struct cpio_owner owner, const char **errmsg)
313	{	294	{
314	static char errbuff[128];	295	static char errbuff[128];
315	const char u, ue, *g;	296	const char u, ue, *g;
316		297
317	*uid = -1;	298	owner->uid = -1;
318	*gid = -1;	299	owner->gid = -1;
319		300
320	if (spec[0] == '\0')	301	owner->uname = NULL;
321	return ("Invalid empty user/group spec");	302	owner->gname = NULL;
		303
		304	if (spec[0] == '\0') {
		305	*errmsg = "Invalid empty user/group spec";
		306	return (-1);
		307	}
322		308
323	/*	309	/*
324	* Split spec into [user][:.][group]	310	* Split spec into [user][:.][group]
Lines 345-369 owner_parse(const char spec, int uid, int *gid) Link Here
345	char *user;	331	char *user;
346	struct passwd *pwent;	332	struct passwd *pwent;
347		333
348	user = (char *)malloc(ue - u + 1);	334	user = malloc(ue - u + 1);
349	if (user == NULL)	335	if (user == NULL)
350	return ("Couldn't allocate memory");	336	goto alloc_error;
351	memcpy(user, u, ue - u);	337	memcpy(user, u, ue - u);
352	user[ue - u] = '\0';	338	user[ue - u] = '\0';
353	if ((pwent = getpwnam(user)) != NULL) {	339	if ((pwent = getpwnam(user)) != NULL) {
354	*uid = pwent->pw_uid;	340	owner->uid = pwent->pw_uid;
		341	owner->uname = strdup(pwent->pw_name);
		342	if (owner->uname == NULL) {
		343	free(user);
		344	goto alloc_error;
		345	}
355	if (*ue != '\0')	346	if (*ue != '\0')
356	*gid = pwent->pw_gid;	347	owner->gid = pwent->pw_gid;
357	} else {	348	} else {
358	char *end;	349	char *end;
359	errno = 0;	350	errno = 0;
360	*uid = (int)strtoul(user, &end, 10);	351	owner->uid = (int)strtoul(user, &end, 10);
361	if (errno \|\| *end != '\0') {	352	if (errno \|\| *end != '\0') {
362	snprintf(errbuff, sizeof(errbuff),	353	snprintf(errbuff, sizeof(errbuff),
363	"Couldn't lookup user ``%s''", user);	354	"Couldn't lookup user ``%s''", user);
364	errbuff[sizeof(errbuff) - 1] = '\0';	355	errbuff[sizeof(errbuff) - 1] = '\0';
365	free(user);	356	free(user);
366	return (errbuff);	357	*errmsg = errbuff;
		358	return (-1);
367	}	359	}
368	}	360	}
369	free(user);	361	free(user);
Lines 372-389 owner_parse(const char spec, int uid, int *gid) Link Here
372	if (*g != '\0') {	364	if (*g != '\0') {
373	struct group *grp;	365	struct group *grp;
374	if ((grp = getgrnam(g)) != NULL) {	366	if ((grp = getgrnam(g)) != NULL) {
375	*gid = grp->gr_gid;	367	owner->gid = grp->gr_gid;
		368	owner->gname = strdup(grp->gr_name);
		369	if (owner->gname == NULL) {
		370	free(owner->uname);
		371	owner->uname = NULL;
		372	goto alloc_error;
		373	}
376	} else {	374	} else {
377	char *end;	375	char *end;
378	errno = 0;	376	errno = 0;
379	*gid = (int)strtoul(g, &end, 10);	377	owner->gid = (int)strtoul(g, &end, 10);
380	if (errno \|\| *end != '\0') {	378	if (errno \|\| *end != '\0') {
381	snprintf(errbuff, sizeof(errbuff),	379	snprintf(errbuff, sizeof(errbuff),
382	"Couldn't lookup group ``%s''", g);	380	"Couldn't lookup group ``%s''", g);
383	errbuff[sizeof(errbuff) - 1] = '\0';	381	errbuff[sizeof(errbuff) - 1] = '\0';
384	return (errbuff);	382	*errmsg = errbuff;
		383	return (-1);
385	}	384	}
386	}	385	}
387	}	386	}
388	return (NULL);	387	return (0);
		388	alloc_error:
		389	*errmsg = "Couldn't allocate memory";
		390	return (-1);
389	}	391	}

Lines 1-27 Link Here

(-)b/contrib/libarchive/cpio/cpio.c (-39 / +31 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2007 Tim Kientzle	4	* Copyright (c) 2003-2007 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer
10	* in this position and unchanged.
11	* 2. Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
16	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
19	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25	*/	6	*/
26		7
27		8
Lines 132-140 main(int argc, char *argv[]) Link Here
132	static char buff[16384];	113	static char buff[16384];
133	struct cpio _cpio; /* Allocated on stack. */	114	struct cpio _cpio; /* Allocated on stack. */
134	struct cpio *cpio;	115	struct cpio *cpio;
		116	struct cpio_owner owner;
135	const char *errmsg;	117	const char *errmsg;
136	char *tptr;	118	char *tptr;
137	int uid, gid;
138	int opt, t;	119	int opt, t;
139		120
140	cpio = &_cpio;	121	cpio = &_cpio;
Lines 142-147 main(int argc, char *argv[]) Link Here
142	cpio->buff = buff;	123	cpio->buff = buff;
143	cpio->buff_size = sizeof(buff);	124	cpio->buff_size = sizeof(buff);
144		125
		126
145	#if defined(HAVE_SIGACTION) && defined(SIGPIPE)	127	#if defined(HAVE_SIGACTION) && defined(SIGPIPE)
146	{ /* Ignore SIGPIPE signals. */	128	{ /* Ignore SIGPIPE signals. */
147	struct sigaction sa;	129	struct sigaction sa;
Lines 161-167 main(int argc, char *argv[]) Link Here
161	#endif	143	#endif
162		144
163	cpio->uid_override = -1;	145	cpio->uid_override = -1;
		146	cpio->uname_override = NULL;
164	cpio->gid_override = -1;	147	cpio->gid_override = -1;
		148	cpio->gname_override = NULL;
165	cpio->argv = argv;	149	cpio->argv = argv;
166	cpio->argc = argc;	150	cpio->argc = argc;
167	cpio->mode = '\0';	151	cpio->mode = '\0';
Lines 320-340 main(int argc, char *argv[]) Link Here
320	cpio->quiet = 1;	304	cpio->quiet = 1;
321	break;	305	break;
322	case 'R': /* GNU cpio, also --owner */	306	case 'R': /* GNU cpio, also --owner */
323	/* TODO: owner_parse should return uname/gname	307	errmsg = NULL;
324	* also; use that to set [ug]name_override. */	308	if (owner_parse(cpio->argument, &owner, &errmsg) != 0) {
325	errmsg = owner_parse(cpio->argument, &uid, &gid);	309	if (!errmsg)
326	if (errmsg) {	310	errmsg = "Error parsing owner";
327	lafe_warnc(-1, "%s", errmsg);	311	lafe_warnc(-1, "%s", errmsg);
328	usage();	312	usage();
329	}	313	}
330	if (uid != -1) {	314	if (owner.uid != -1)
331	cpio->uid_override = uid;	315	cpio->uid_override = owner.uid;
332	cpio->uname_override = NULL;	316	if (owner.uname != NULL)
333	}	317	cpio->uname_override = owner.uname;
334	if (gid != -1) {	318	if (owner.gid != -1)
335	cpio->gid_override = gid;	319	cpio->gid_override = owner.gid;
336	cpio->gname_override = NULL;	320	if (owner.gname != NULL)
337	}	321	cpio->gname_override = owner.gname;
338	break;	322	break;
339	case 'r': /* POSIX 1997 */	323	case 'r': /* POSIX 1997 */
340	cpio->option_rename = 1;	324	cpio->option_rename = 1;
Lines 439-449 main(int argc, char *argv[]) Link Here
439	}	423	}
440		424
441	archive_match_free(cpio->matching);	425	archive_match_free(cpio->matching);
442	free_cache(cpio->gname_cache);
443	free_cache(cpio->uname_cache);	426	free_cache(cpio->uname_cache);
		427	free(cpio->uname_override);
		428	free_cache(cpio->gname_cache);
		429	free(cpio->gname_override);
444	archive_read_close(cpio->archive_read_disk);	430	archive_read_close(cpio->archive_read_disk);
445	archive_read_free(cpio->archive_read_disk);	431	archive_read_free(cpio->archive_read_disk);
446	free(cpio->destdir);	432	free(cpio->destdir);
		433
447	passphrase_free(cpio->ppbuff);	434	passphrase_free(cpio->ppbuff);
448	return (cpio->return_value);	435	return (cpio->return_value);
449	}	436	}
Lines 728-741 file_to_archive(struct cpio cpio, const char srcpath) Link Here
728	return (r);	715	return (r);
729	}	716	}
730		717
731	if (cpio->uid_override >= 0) {	718	if (cpio->uid_override >= 0)
732	archive_entry_set_uid(entry, cpio->uid_override);	719	archive_entry_set_uid(entry, cpio->uid_override);
		720	if (cpio->gname_override != NULL)
733	archive_entry_set_uname(entry, cpio->uname_override);	721	archive_entry_set_uname(entry, cpio->uname_override);
734	}	722	if (cpio->gid_override >= 0)
735	if (cpio->gid_override >= 0) {
736	archive_entry_set_gid(entry, cpio->gid_override);	723	archive_entry_set_gid(entry, cpio->gid_override);
		724	if (cpio->gname_override != NULL)
737	archive_entry_set_gname(entry, cpio->gname_override);	725	archive_entry_set_gname(entry, cpio->gname_override);
738	}
739		726
740	/*	727	/*
741	* Generate a destination path for this entry.	728	* Generate a destination path for this entry.
Lines 1015-1027 mode_in(struct cpio *cpio) Link Here
1015	fprintf(stderr, ".");	1002	fprintf(stderr, ".");
1016	if (cpio->uid_override >= 0)	1003	if (cpio->uid_override >= 0)
1017	archive_entry_set_uid(entry, cpio->uid_override);	1004	archive_entry_set_uid(entry, cpio->uid_override);
		1005	if (cpio->uname_override != NULL)
		1006	archive_entry_set_uname(entry, cpio->uname_override);
1018	if (cpio->gid_override >= 0)	1007	if (cpio->gid_override >= 0)
1019	archive_entry_set_gid(entry, cpio->gid_override);	1008	archive_entry_set_gid(entry, cpio->gid_override);
		1009	if (cpio->gname_override != NULL)
		1010	archive_entry_set_gname(entry, cpio->gname_override);
1020	r = archive_write_header(ext, entry);	1011	r = archive_write_header(ext, entry);
1021	if (r != ARCHIVE_OK) {	1012	if (r != ARCHIVE_OK) {
1022	fprintf(stderr, "%s: %s\n",	1013	fprintf(stderr, "%s: %s\n",
1023	archive_entry_pathname(entry),	1014	archive_entry_pathname(entry),
1024	archive_error_string(ext));	1015	archive_error_string(ext));
		1016	cpio->return_value = 1;
1025	} else if (!archive_entry_size_is_set(entry)	1017	} else if (!archive_entry_size_is_set(entry)
1026	\|\| archive_entry_size(entry) > 0) {	1018	\|\| archive_entry_size(entry) > 0) {
1027	r = extract_data(a, ext);	1019	r = extract_data(a, ext);

Lines 1-26 Link Here

(-)b/contrib/libarchive/cpio/cpio.h (-21 / +9 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2007 Tim Kientzle	4	* Copyright (c) 2003-2007 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25		7
26	#ifndef CPIO_H_INCLUDED	8	#ifndef CPIO_H_INCLUDED
Lines 94-101 struct cpio { Link Here
94	char *ppbuff;	76	char *ppbuff;
95	};	77	};
96		78
97	const char owner_parse(const char , int , int );	79	struct cpio_owner {
		80	int uid;
		81	int gid;
		82	char *uname;
		83	char *gname;
		84	};
98		85
		86	int owner_parse(const char , struct cpio_owner , const char **);
99		87
100	/* Fake short equivalents for long options that otherwise lack them. */	88	/* Fake short equivalents for long options that otherwise lack them. */
101	enum {	89	enum {

Lines 1-26 Link Here

(-)b/contrib/libarchive/cpio/cpio_platform.h (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2007 Tim Kientzle	4	* Copyright (c) 2003-2007 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25		7
26	/*	8	/*

Lines 1-26 Link Here

(-)b/contrib/libarchive/cpio/test/test.h (-20 / +2 lines)
1	/*	1	/*
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2017 Tim Kientzle	4	* Copyright (c) 2003-2017 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25		7
26	/* Every test program should #include "test.h" as the first thing. */	8	/* Every test program should #include "test.h" as the first thing. */

Lines 1-26 Link Here

(-)b/contrib/libarchive/cpio/test/test_0.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2007 Tim Kientzle	4	* Copyright (c) 2003-2007 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8

Lines 1-26 Link Here

(-)b/contrib/libarchive/cpio/test/test_basic.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2007 Tim Kientzle	4	* Copyright (c) 2003-2007 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8

Lines 1-26 Link Here

(-)b/contrib/libarchive/cpio/test/test_cmdline.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2009 Tim Kientzle	4	* Copyright (c) 2003-2009 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8

Lines 1-26 Link Here

(-)b/contrib/libarchive/cpio/test/test_extract_cpio_Z.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2012 Michihiro NAKAJIMA	4	* Copyright (c) 2012 Michihiro NAKAJIMA
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8

Added Link Here

(-)b/contrib/libarchive/cpio/test/test_extract_cpio_absolute_paths.c (+53 lines)
1	/*-
2	* SPDX-License-Identifier: BSD-2-Clause
3	*
4	* Copyright (c) 2024 Mostyn Bramley-Moore <mostyn@antipode.se>
5	*/
6
7	#include "test.h"
8
9	#include <stdlib.h>
10	#include <string.h>
11
12	#if defined(_WIN32) && !defined(__CYGWIN__)
13	#define UNLINK _unlink
14	#else
15	#define UNLINK unlink
16	#endif
17
18	DEFINE_TEST(test_extract_cpio_absolute_paths)
19	{
20	int r;
21
22	// Create an absolute path for a test file inside testworkdir.
23	const char *entry_suffix = "/cpio-noabs";
24	size_t entry_suffix_length = strlen(entry_suffix);
25	size_t testworkdir_length = strlen(testworkdir);
26	size_t temp_absolute_file_name_length = testworkdir_length + entry_suffix_length;
27	char *temp_absolute_file_name = calloc(1, temp_absolute_file_name_length + 1); // +1 for null character.
28	assertEqualInt(snprintf(temp_absolute_file_name, temp_absolute_file_name_length + 1, "%s%s", testworkdir, entry_suffix),
29	temp_absolute_file_name_length);
30
31	// Create the file.
32	const char *sample_data = "test file from test_extract_cpio_absolute_paths";
33	assertMakeFile(temp_absolute_file_name, 0644, sample_data);
34
35	// Create an archive with the test file, using an absolute path.
36	assertMakeFile("filelist", 0644, temp_absolute_file_name);
37	r = systemf("%s -o < filelist > archive.cpio 2> stderr1.txt", testprog);
38	assertEqualInt(r, 0);
39
40	// Ensure that the temp file does not exist.
41	UNLINK(temp_absolute_file_name);
42
43	// We should refuse to create the absolute path without --insecure.
44	r = systemf("%s -i < archive.cpio 2> stderr2.txt", testprog);
45	assert(r != 0);
46	assertFileNotExists(temp_absolute_file_name);
47	UNLINK(temp_absolute_file_name); // Cleanup just in case.
48
49	// But if we specify --insecure then the absolute path should be created.
50	r = systemf("%s -i --insecure < archive.cpio 2> stderr3.txt", testprog);
51	assert(r == 0);
52	assertFileExists(temp_absolute_file_name);
53	}

Lines 1-26 Link Here

(-)b/contrib/libarchive/cpio/test/test_extract_cpio_lz4.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2012,2014 Michihiro NAKAJIMA	4	* Copyright (c) 2012,2014 Michihiro NAKAJIMA
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8

Lines 1-26 Link Here

(-)b/contrib/libarchive/cpio/test/test_format_newc.c (-23 / +5 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2007 Tim Kientzle	4	* Copyright (c) 2003-2007 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8
Lines 194-204 DEFINE_TEST(test_format_newc) Link Here
194	assertEqualMem(e + 0, "070701", 6); /* Magic */	176	assertEqualMem(e + 0, "070701", 6); /* Magic */
195	ino = from_hex(e + 6, 8); /* ino */	177	ino = from_hex(e + 6, 8); /* ino */
196	#if defined(_WIN32) && !defined(__CYGWIN__)	178	#if defined(_WIN32) && !defined(__CYGWIN__)
197	/* Group members bits and others bits do not work. */	179	/* Group members bits and others bits do not work. */
198	assertEqualInt(0x8180, from_hex(e + 14, 8) & 0xffc0); /* Mode */	180	assertEqualInt(0x8180, from_hex(e + 14, 8) & 0xffc0); /* Mode */
199	#else	181	#else
200	assertEqualInt(0x81a4, from_hex(e + 14, 8)); /* Mode */	182	assertEqualInt(0x81a4, from_hex(e + 14, 8)); /* Mode */
201	#endif	183	#endif
202	#if defined(_WIN32)	184	#if defined(_WIN32)
203	uid = from_hex(e + 22, 8);	185	uid = from_hex(e + 22, 8);
204	#else	186	#else
Lines 308-314 DEFINE_TEST(test_format_newc) Link Here
308	failure("If these aren't the same, then the hardlink detection failed to match them.");	290	failure("If these aren't the same, then the hardlink detection failed to match them.");
309	assertEqualInt(ino, from_hex(e + 6, 8)); /* ino */	291	assertEqualInt(ino, from_hex(e + 6, 8)); /* ino */
310	#if defined(_WIN32) && !defined(__CYGWIN__)	292	#if defined(_WIN32) && !defined(__CYGWIN__)
311	/* Group members bits and others bits do not work. */	293	/* Group members bits and others bits do not work. */
312	assertEqualInt(0x8180, from_hex(e + 14, 8) & 0xffc0); /* Mode */	294	assertEqualInt(0x8180, from_hex(e + 14, 8) & 0xffc0); /* Mode */
313	#else	295	#else
314	assertEqualInt(0x81a4, from_hex(e + 14, 8)); /* Mode */	296	assertEqualInt(0x81a4, from_hex(e + 14, 8)); /* Mode */

Lines 1-26 Link Here

(-)b/contrib/libarchive/cpio/test/test_gcpio_compat.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2007 Tim Kientzle	4	* Copyright (c) 2003-2007 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8

Lines 1-26 Link Here

(-)b/contrib/libarchive/cpio/test/test_missing_file.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2016 Tim Kientzle	4	* Copyright (c) 2016 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8

Lines 1-26 Link Here

(-)b/contrib/libarchive/cpio/test/test_option_0.c (-20 / +2 lines)
1	/*-	1	/*-
		2	* SPDX-License-Identifier: BSD-2-Clause
		3	*
2	* Copyright (c) 2003-2010 Tim Kientzle	4	* Copyright (c) 2003-2010 Tim Kientzle
3	* All rights reserved.	5	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17	* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/	6	*/
25	#include "test.h"	7	#include "test.h"
26		8